progress

28 files changed, 20096 insertions, 20765 deletions

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 7e5e4fb05..63ec80c0b 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -80,8 +80,8 @@
     "test/snippets/package-json-exports/_node_modules_copy": true,
     "src/js/out": true,
     "packages/bun-uws/fuzzing/seed-corpus/": true,
-    "**/*.dep": true,
-    "**/CMakeFiles": true
+    "**/*.dep": true
+    // "**/CMakeFiles": true
   },
   "C_Cpp.files.exclude": {
     "**/.vscode": true,
diff --git a/CMakeLists.txt b/CMakeLists.txt
index a37c34eb3..7d488ad43 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,20 +1,50 @@
 cmake_minimum_required(VERSION 3.25)
 cmake_policy(SET CMP0091 NEW)
+set(CMAKE_COLOR_DIAGNOSTICS ON)
 
+# --- LLVM ---
+# This has to be done before `project` in order to override the default compiler
 if(UNIX)
-    set(CLANG_VERSION 16)
+    set(LLVM_VERSION 17)
+
+    # function(validate_llvm_path validator_result_var item)
+    #     execute_process(COMMAND ${item}/bin/llvm-config --version OUTPUT_VARIABLE FOUND_LLVM_VERSION)
+    #     if (FOUND_LLVM_VERSION MATCHES "^${LLVM_VERSION}.")
+    #         set(${validator_result_var} TRUE PARENT_SCOPE)
+    #     else()
+    #         message(STATUS "Found LLVM version: ${FOUND_LLVM_VERSION}")
+    #         set(${validator_result_var} FALSE PARENT_SCOPE)
+    #     endif()
+    # endfunction()
+
     find_path(
-        LLVM_TOOLS_BINARY_DIR
-        NAMES clang++-${CLANG_VERSION} clang-${CLANG_VERSION} clang++ clang
-        PATHS ENV PATH /usr/bin /usr/local/bin /opt/homebrew/opt/llvm@${CLANG_VERSION}/bin /opt/homebrew/bin
+        LLVM_PREFIX
+        NAMES bin/clang++-${LLVM_VERSION} bin/clang-${LLVM_VERSION} bin/clang++ bin/clang
+        PATHS ENV PATH /usr /usr/local /opt/homebrew/opt/llvm@${LLVM_VERSION} /opt/homebrew
+        NO_CACHE
+        DOC "Path to LLVM binary directory"
     )
-    set(CMAKE_CXX_COMPILER "${LLVM_TOOLS_BINARY_DIR}/clang++")
-    set(CMAKE_C_COMPILER "${LLVM_TOOLS_BINARY_DIR}/clang")
+    if(LLVM_PREFIX MATCHES "/$")
+        string(REGEX REPLACE "/$" "" LLVM_PREFIX "${LLVM_PREFIX}")
+    endif()
+
+    if (NOT EXISTS "${LLVM_PREFIX}/bin/clang")
+        message(FATAL_ERROR "Could not find LLVM ${LLVM_VERSION} installed on your system.")
+    endif()
+
+    set(CMAKE_CXX_COMPILER "${LLVM_PREFIX}/bin/clang++")
+    set(CMAKE_C_COMPILER "${LLVM_PREFIX}/bin/clang")
     set(CMAKE_CXX_COMPILER_ID "Clang")
+    message(STATUS "Using LLVM at: ${LLVM_PREFIX}")
 endif()
 
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_C_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_C_STANDARD_REQUIRED ON)
 project(Bun VERSION "1.0.7")
 
+# --- Build Type ---
 if(NOT CMAKE_BUILD_TYPE)
     message(WARNING "No CMAKE_BUILD_TYPE value specified, defaulting to Debug.\nSet a build type with -DCMAKE_BUILD_TYPE=<Debug|Release>")
     set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Choose the type of build (Debug, Release)" FORCE)
@@ -28,49 +58,19 @@ else()
 endif()
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     set(DEBUG ON)
-    set(target_name "bun-debug")
-else()
+    set(ZIG_OPTIMIZE "Debug")
+    set(bun "bun-debug")
+elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
     set(DEBUG OFF)
-    set(target_name "bun")
-endif()
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_C_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_C_STANDARD_REQUIRED ON)
-
-# Zig Compiler
-function(validate_zig validator_result_var item)
-    set(${validator_result_var} FALSE PARENT_SCOPE)
-    # We will allow any valid zig compiler, as long as it contains some text from `zig zen`
-    execute_process(COMMAND ${item} zen OUTPUT_VARIABLE ZIG_ZEN_OUTPUT)
-    if(ZIG_ZEN_OUTPUT MATCHES "Together we serve the users")
-        set(${validator_result_var} TRUE PARENT_SCOPE)
-    else()
-        set(${validator_result_var} FALSE PARENT_SCOPE)
-    endif()
-endfunction()
-find_program(ZIG_COMPILER zig REQUIRED DOC "Path to the Zig compiler" VALIDATOR validate_zig)
-message(STATUS "Found Zig Compiler: ${ZIG_COMPILER}")
-
-# Bun. This is a sort of chicken-and-egg problem where you need `bun` to build `bun`
-# maybe in the future we can make it possible to use bun-polyfills in combination
-# with Node to fufill this requirement.
-find_program(BUN_EXECUTABLE bun REQUIRED DOC "Path to an already built release of Bun")
-
-#
-set(DEFAULT_ON_UNLESS_WINDOWS ON)
-if (WIN32)
-    set(DEFAULT_ON_UNLESS_WINDOWS OFF)
+    set(ZIG_OPTIMIZE "ReleaseFast")
+    set(bun "bun")
 endif()
 
-set(DEFAULT_USE_STATIC_SQLITE ON)
-if(APPLE)
-    set(DEFAULT_USE_STATIC_SQLITE OFF)
-endif()
+# --- Build Flags ---
+set(DEFAULT_ON_UNLESS_WINDOWS $<NOT:$<BOOL:${WIN32}>>)
+set(DEFAULT_ON_UNLESS_APPLE $<NOT:$<BOOL:${APPLE}>>)
 
-# User options
-option(USE_STATIC_SQLITE "Statically link SQLite?" ${DEFAULT_USE_STATIC_SQLITE})
+option(USE_STATIC_SQLITE "Statically link SQLite?" ${DEFAULT_ON_UNLESS_APPLE})
 option(USE_CUSTOM_ZLIB "Use Bun's recommended version of zlib" ${DEFAULT_ON_UNLESS_WINDOWS})
 option(USE_CUSTOM_BORINGSSL "Use Bun's recommended version of BoringSSL" ON)
 option(USE_CUSTOM_LIBARCHIVE "Use Bun's recommended version of libarchive" ON)
@@ -81,13 +81,12 @@ option(USE_CUSTOM_BASE64 "Use Bun's recommended version of libbase64" ON)
 option(USE_CUSTOM_LOLHTML "Use Bun's recommended version of lolhtml" ON)
 option(USE_CUSTOM_TINYCC "Use Bun's recommended version of tinycc" ON)
 option(USE_CUSTOM_LIBUV "Use Bun's recommended version of libuv (Windows only)" OFF)
-option(USE_BASELINE_BUILD "Build Bun for older CPUs" OFF)
+option(USE_BASELINE_BUILD "Build Bun for baseline (older) CPUs" OFF)
 
 set(ERROR_LIMIT 100 CACHE STRING "Maximum number of errors to show when compiling C++ code")
 
-# CPU Target
 if(NOT CPU_TARGET)
-    set(CPU_TARGET "native")
+    set(CPU_TARGET "native" CACHE STRING "CPU target for the compiler" FORCE)
     if (ARCH STREQUAL "x86_64")
         if (NOT MSVC)
             if (USE_BASELINE_BUILD)
@@ -100,6 +99,37 @@ if(NOT CPU_TARGET)
 endif()
 message(STATUS "Building for CPU Target: ${CPU_TARGET}")
 
+# --- CLI Paths ---
+
+# Zig Compiler
+function(validate_zig validator_result_var item)
+    set(${validator_result_var} FALSE PARENT_SCOPE)
+    # We will allow any valid zig compiler, as long as it contains some text from `zig zen`
+    execute_process(COMMAND ${item} zen OUTPUT_VARIABLE ZIG_ZEN_OUTPUT)
+    if(ZIG_ZEN_OUTPUT MATCHES "Together we serve the users")
+        set(${validator_result_var} TRUE PARENT_SCOPE)
+    else()
+        set(${validator_result_var} FALSE PARENT_SCOPE)
+    endif()
+endfunction()
+find_program(ZIG_COMPILER zig REQUIRED DOC "Path to the Zig compiler" VALIDATOR validate_zig)
+message(STATUS "Found Zig Compiler: ${ZIG_COMPILER}")
+
+# An existing Buntime. This is a sort of chicken-and-egg problem where you need `bun` to build `bun`
+# maybe in the future we can make it possible to use bun-polyfills in combination
+# with Node to fufill this requirement.
+find_program(BUN_EXECUTABLE bun REQUIRED DOC "Path to an already built release of Bun")
+
+# CCache
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    message(STATUS "Using ccache: ${CCACHE_PROGRAM}")
+endif()
+
+# --- Dependencies ---
+
 # WebKit
 if(NOT WEBKIT_DIR)
     # TODO: allow this to point to the actual webkit cmake file to allow easier rebuilds
@@ -133,79 +163,70 @@ if(NOT DEFINED ASSERT_ENABLED)
         set(ASSERT_ENABLED "0")
     endif()
 endif()
-if(ASSERT_ENABLED)
-    message(STATUS "C++ Assertions enabled")
-else()
-    message(STATUS "C++ Assertions disabled")
-endif()
-
-set(BUN_DEPS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src/deps" CACHE STRING "Directory holding submodules" )
-set(BUN_LIB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src/deps" CACHE STRING "Directory holding static libraries" )
-
-add_compile_options(-D_HAS_EXCEPTIONS=0)
-
-# CCACHE
-find_program(CCACHE_PROGRAM ccache)
-if(CCACHE_PROGRAM)
-    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
-    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
-    message(STATUS "Using ccache: ${CCACHE_PROGRAM}")
-endif()
-
-file(GLOB bun_SRC CONFIGURE_DEPENDS
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/deps/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/io/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/modules/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/WebCore/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/sqlite/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/webcrypto/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/webcrypto/*/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/js/out/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/deps/picohttpparser/picohttpparser.c"
+message(STATUS "C++ Assertions: ${ASSERT_ENABLED}")
+
+# ---
+
+set(BUN_SRC "${CMAKE_CURRENT_SOURCE_DIR}/src")
+set(BUN_WORKDIR "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${bun}.dir")
+set(BUN_DEPS_DIR "${BUN_SRC}/deps")
+set(BUN_CODEGEN_SRC "${BUN_SRC}/codegen")
+
+file(GLOB BUN_CPP CONFIGURE_DEPENDS
+    "${BUN_SRC}/deps/*.cpp"
+    "${BUN_SRC}/io/*.cpp"
+    "${BUN_SRC}/bun.js/modules/*.cpp"
+    "${BUN_SRC}/bun.js/bindings/*.cpp"
+    "${BUN_SRC}/bun.js/bindings/WebCore/*.cpp"
+    "${BUN_SRC}/bun.js/bindings/sqlite/*.cpp"
+    "${BUN_SRC}/bun.js/bindings/webcrypto/*.cpp"
+    "${BUN_SRC}/bun.js/bindings/webcrypto/*/*.cpp"
+    "${BUN_SRC}/deps/picohttpparser/picohttpparser.c"
 )
 
-file(GLOB uSockets_FILES CONFIGURE_DEPENDS
-    "${CMAKE_CURRENT_SOURCE_DIR}/packages/bun-usockets/src/*.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/packages/bun-usockets/src/eventing/*.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/packages/bun-usockets/src/internal/*.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/packages/bun-usockets/src/crypto/*.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/packages/bun-usockets/src/crypto/*.cpp"
+set(USOCKETS_SRC "${CMAKE_CURRENT_SOURCE_DIR}/packages/bun-usockets/src")
+file(GLOB USOCKETS_FILES CONFIGURE_DEPENDS
+    "${USOCKETS_SRC}/*.c"
+    "${USOCKETS_SRC}/eventing/*.c"
+    "${USOCKETS_SRC}/internal/*.c"
+    "${USOCKETS_SRC}/crypto/*.c"
+    "${USOCKETS_SRC}/crypto/*.cpp"
 )
 
-# Class bindings generator
-file(GLOB Bun_CLASSES_TS_FILES CONFIGURE_DEPENDS
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/*.classes.ts"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/api/*.classes.ts"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/test/*.classes.ts"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/webcore/*.classes.ts"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/node/*.classes.ts"
+# --- Classes Generator ---
+file(GLOB BUN_CLASSES_TS CONFIGURE_DEPENDS
+    "${BUN_SRC}/bun.js/*.classes.ts"
+    "${BUN_SRC}/bun.js/api/*.classes.ts"
+    "${BUN_SRC}/bun.js/test/*.classes.ts"
+    "${BUN_SRC}/bun.js/webcore/*.classes.ts"
+    "${BUN_SRC}/bun.js/node/*.classes.ts"
 )
 add_custom_command(
-    OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/ZigGeneratedClasses.h"
-           "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/ZigGeneratedClasses.cpp"
-           "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureHeader.h"
-           "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/ZigGeneratedClasses+DOMClientIsoSubspaces.h"
-           "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/ZigGeneratedClasses+DOMIsoSubspaces.h"
-           "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureImpl.h"
-           "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/generated_classes.zig"
-    COMMAND ${BUN_EXECUTABLE} "src/codegen/generate-classes.ts" ${Bun_CLASSES_TS_FILES}
+    OUTPUT "${BUN_WORKDIR}/generated-classes/ZigGeneratedClasses.h"
+           "${BUN_WORKDIR}/generated-classes/ZigGeneratedClasses.cpp"
+           "${BUN_WORKDIR}/generated-classes/ZigGeneratedClasses+lazyStructureHeader.h"
+           "${BUN_WORKDIR}/generated-classes/ZigGeneratedClasses+DOMClientIsoSubspaces.h"
+           "${BUN_WORKDIR}/generated-classes/ZigGeneratedClasses+DOMIsoSubspaces.h"
+           "${BUN_WORKDIR}/generated-classes/ZigGeneratedClasses+lazyStructureImpl.h"
+           "${BUN_WORKDIR}/generated-classes/ZigGeneratedClasses.zig"
+    COMMAND ${BUN_EXECUTABLE} "${BUN_CODEGEN_SRC}/generate-classes.ts" ${BUN_CLASSES_TS} "${BUN_WORKDIR}/generated-classes"
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    MAIN_DEPENDENCY "${CMAKE_CURRENT_SOURCE_DIR}/src/codegen/generate-classes.ts"
-    DEPENDS ${Bun_CLASSES_TS_FILES}
+    MAIN_DEPENDENCY "${BUN_CODEGEN_SRC}/generate-classes.ts"
+    DEPENDS ${BUN_CLASSES_TS}
     VERBATIM
-    COMMENT "Generating class bindings"    
+    COMMENT "Generating *.classes.ts bindings"
 )
+include_directories("${BUN_WORKDIR}/generated-classes")
 
 # JSSink generator
-add_custom_command(
-    OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/JSSink.cpp"
-           "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/JSSink.h"
-    COMMAND ${BUN_EXECUTABLE} "src/codegen/generate-jssink.ts"
-    VERBATIM 
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    COMMENT "Generating JSSink"
-)
+# add_custom_command(
+#     OUTPUT "${BUN_SRC}/bun.js/bindings/JSSink.cpp"
+#            "${BUN_SRC}/bun.js/bindings/JSSink.h"
+#     COMMAND ${BUN_EXECUTABLE} "src/codegen/generate-jssink.ts"
+#     VERBATIM 
+#     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+#     COMMENT "Generating JSSink"
+# )
 
 # # Append the given dependencies to the source file
 # macro(WEBKIT_ADD_SOURCE_DEPENDENCIES _source _deps)
@@ -232,7 +253,7 @@ add_custom_command(
 #     src/bun.js/bindings/ProcessBindingConstants.cpp
 #     src/bun.js/bindings/ProcessBindingNatives.cpp
 # )
-# set(HASH_LUT_GENERATOR ${CMAKE_CURRENT_SOURCE_DIR}/src/codegen/create_hash_table)
+# set(HASH_LUT_GENERATOR ${BUN_SRC}/codegen/create_hash_table)
 
 # macro(GENERATE_HASH_LUT _input _output)
 #     add_custom_command(
@@ -251,6 +272,65 @@ add_custom_command(
 #     GENERATE_HASH_LUT(${CMAKE_CURRENT_SOURCE_DIR}/${_file} ${JavaScriptCore_DERIVED_SOURCES_DIR}/${_name}.lut.h)
 # endforeach()
 
+set(IDENTIFIER_CACHE_FILES 
+    "${BUN_SRC}/js_lexer/id_continue_bitset.blob" 
+    "${BUN_SRC}/js_lexer/id_continue_bitset.meta.blob" 
+    "${BUN_SRC}/js_lexer/id_start_bitset.blob"
+    "${BUN_SRC}/js_lexer/id_start_bitset.meta.blob")
+
+file(GLOB ZIG_FILES
+    "${BUN_SRC}/*.zig"
+    "${BUN_SRC}/*/*.zig"
+    "${BUN_SRC}/*/**/*.zig"
+    "${BUN_SRC}/*/*/*/*.zig"
+)
+
+set(BUN_ZIG_OBJ "${BUN_WORKDIR}/${bun}.o")
+add_custom_command(
+    OUTPUT "${BUN_ZIG_OBJ}"
+    COMMAND "${ZIG_COMPILER}" "build" "obj"
+        "-Doptimize=${ZIG_OPTIMIZE}"
+        "-Doutput-dir=${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${bun}.dir"
+        "-Dcpu=${CPU_TARGET}"
+        "-Dgenerated-files=${BUN_WORKDIR}"
+
+    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/build.zig ${ZIG_FILES} "${BUN_WORKDIR}/generated-classes/ZigGeneratedClasses.zig"
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    COMMENT "Building zig code"
+    VERBATIM
+    USES_TERMINAL
+)
+
+# add_executable(${bun} ${BUN_CPP} ${USOCKETS_FILES} ${BUN_ZIG_OBJ} ${EXTRA_SRC})
+add_executable(${bun} "/Users/dave/code/bun/src/bun.js/bindings/JSSocketAddress.cpp" "${BUN_ZIG_OBJ}")
+
+# Set /subsystem:console on bun for windows
+if (WIN32)
+    set_target_properties(${bun} PROPERTIES LINK_FLAGS " /SUBSYSTEM:CONSOLE ")
+endif()
+
+# TODO: not good enough
+# add_custom_command(
+#     TARGET bun PRE_BUILD
+#     COMMAND ${BUN_EXECUTABLE} "${BUN_SRC}/js/_codegen/index.ts"
+#     DEPENDS "${BUN_SRC}/js/**/*.{js,ts}"
+#     COMMENT "Bundling JS modules"
+# )
+
+set_target_properties(${bun} PROPERTIES
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED YES
+    CXX_EXTENSIONS YES
+    CXX_VISIBILITY_PRESET hidden
+    C_STANDARD 17
+    C_STANDARD_REQUIRED YES
+    VISIBILITY_INLINES_HIDDEN YES
+)
+
+# --- Flags and Defines ---
+add_compile_options(
+    -D_HAS_EXCEPTIONS=0
+)
 add_compile_definitions(
     # TODO: are all of these variables strictly necessary?
     "LIBUS_USE_OPENSSL=1"
@@ -270,7 +350,6 @@ add_compile_definitions(
     "NDEBUG=$<IF:$<CONFIG:ASSERT_ENABLED>,0,1>"
     "ASSERT_ENABLED=$<IF:$<CONFIG:ASSERT_ENABLED>,1,0>"
 )
-
 include_directories(
     packages/bun-uws
     packages
@@ -297,9 +376,7 @@ include_directories(
     ${WEBKIT_DIR}/WTF/PrivateHeaders
 )
 
-set(BUN_OBJECT_FILE zig-out/lib/bun.o)
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
-    set(BUN_OBJECT_FILE zig-out/lib/bun-debug.o)
     if (NOT MSVC)
         string(APPEND CMAKE_CXX_FLAGS " -g3 -O1")
         string(APPEND CMAKE_C_FLAGS " -g3 -O1")
@@ -316,9 +393,7 @@ else ()
     string(APPEND CMAKE_C_FLAGS " /O2")
 endif()
 
-set(EXTRA_SRC "")
 if (WIN32)
-    set(EXTRA_SRC "${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings/musl-memmem.c")
     add_compile_definitions(
         "WIN32"
         "_WINDOWS"
@@ -366,55 +441,6 @@ if (NOT MSVC)
     string(APPEND CMAKE_C_FLAGS " -march=${CPU_TARGET} -mtune=${CPU_TARGET}")
 endif()
 
-set(IDENTIFIER_CACHE_FILES 
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/js_lexer/id_continue_bitset.blob" 
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/js_lexer/id_continue_bitset.meta.blob" 
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/js_lexer/id_start_bitset.blob"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/js_lexer/id_start_bitset.meta.blob")
-
-file(GLOB ZIG_FILES CONFIGURE_DEPENDS 
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/*.zig"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/*/*.zig"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/*/**/*.zig"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/*/*/*/*.zig"
-)
-
-add_custom_command(
-    OUTPUT "${BUN_OBJECT_FILE}"
-    COMMAND "${ZIG_COMPILER}" build obj -Doptimize=${CMAKE_BUILD_TYPE} -Doutput-dir=${CMAKE_CURRENT_SOURCE_DIR}/zig-out/lib -Dcpu=${CPU_TARGET}
-    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/build.zig ${ZIG_FILES}
-    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    COMMENT "Building zig code"
-    VERBATIM
-)
-
-add_executable(${target_name} ${bun_SRC} ${uSockets_FILES} ${BUN_OBJECT_FILE} ${EXTRA_SRC})
-
-# Set /subsystem:console on bun for windows
-if (WIN32)
-    set_target_properties(${target_name} PROPERTIES LINK_FLAGS " /SUBSYSTEM:CONSOLE ")
-endif()
-
-# TODO: not good enough
-# add_custom_command(
-#     TARGET bun PRE_BUILD
-#     COMMAND ${BUN_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/src/js/_codegen/index.ts"
-#     DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/js/**/*.{js,ts}"
-#     COMMENT "Bundling JS modules"
-# )
-
-set_target_properties(${target_name} PROPERTIES
-    CXX_STANDARD 20
-    CXX_STANDARD_REQUIRED YES
-    CXX_EXTENSIONS YES
-    CXX_VISIBILITY_PRESET hidden
-    C_STANDARD 17
-    C_STANDARD_REQUIRED YES
-    VISIBILITY_INLINES_HIDDEN YES
-)
-
-set(CMAKE_COLOR_DIAGNOSTICS ON)
-
 if (APPLE)
     # TODO: a much better check can be done to find this path
     find_path(
@@ -427,18 +453,18 @@ if (APPLE)
     )
     
     # resolv might not go here. i think it's c-ares related.
-    target_link_libraries(${target_name} PRIVATE "resolv")
+    target_link_libraries(${bun} PRIVATE "resolv")
 
-    target_link_libraries(${target_name} PRIVATE "icucore")
-    target_link_libraries(${target_name} PRIVATE "${ICONV_DIR}/lib/libiconv.a")
-    target_link_libraries(${target_name} PRIVATE "${ICU4C_DIR}/lib/libicudata.a")
-    target_link_libraries(${target_name} PRIVATE "${ICU4C_DIR}/lib/libicui18n.a")
-    target_link_libraries(${target_name} PRIVATE "${ICU4C_DIR}/lib/libicuuc.a")
+    target_link_libraries(${bun} PRIVATE "icucore")
+    target_link_libraries(${bun} PRIVATE "${ICONV_DIR}/lib/libiconv.a")
+    target_link_libraries(${bun} PRIVATE "${ICU4C_DIR}/lib/libicudata.a")
+    target_link_libraries(${bun} PRIVATE "${ICU4C_DIR}/lib/libicui18n.a")
+    target_link_libraries(${bun} PRIVATE "${ICU4C_DIR}/lib/libicuuc.a")
     include_directories(${ICU4C_DIR}/include)
 elseif (LINUX)
     string(APPEND CMAKE_CXX_FLAGS " -static-libstdc++ -static-libgcc -fno-omit-frame-pointer")
     string(APPEND CMAKE_C_FLAGS " -static-libgcc -fno-omit-frame-pointer")
-    target_link_libraries(${target_name} PRIVATE "c")
+    target_link_libraries(${bun} PRIVATE "c")
     string(APPEND CMAKE_LINKER_FLAGS 
         " -Wl,--compress-debug-sections=zlib "
         " -l:libatomic.a "
@@ -470,84 +496,84 @@ elseif (LINUX)
 endif()
 
 if (USE_CUSTOM_ZLIB AND (NOT WIN32))
-    target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libz.a")
+    target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libz.a")
     include_directories(${BUN_DEPS_DIR}/zlib/include)
 else ()
     find_package(ZLIB REQUIRED)
-    target_link_libraries(${target_name} PRIVATE ZLIB::ZLIB)
+    target_link_libraries(${bun} PRIVATE ZLIB::ZLIB)
 endif ()
 
 if (USE_CUSTOM_BORINGSSL)
     include_directories(src/deps/boringssl/include)
     if (WIN32)
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/crypto.lib")
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/ssl.lib")
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/decrepit.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/crypto.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/ssl.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/decrepit.lib")
     else()
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libcrypto.a")
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libssl.a")
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libdecrepit.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libcrypto.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libssl.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libdecrepit.a")
     endif()
 else ()
     include(FindBoringSSL)
-    FindBoringSSL(${target_name})
+    FindBoringSSL(${bun})
 endif()
 
 if (USE_CUSTOM_LIBARCHIVE)
     include_directories(src/deps/libarchive/include)
     if (WIN32)
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/archive.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/archive.lib")
     else()
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libarchive.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libarchive.a")
     endif()
 else ()
     find_package(LibArchive REQUIRED)
-    target_link_libraries(${target_name} PRIVATE LibArchive::LibArchive)
+    target_link_libraries(${bun} PRIVATE LibArchive::LibArchive)
 endif()
 
 if (USE_CUSTOM_MIMALLOC)
     include_directories(src/deps/mimalloc/include)
     if (WIN32)
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/mimalloc-static.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/mimalloc-static.lib")
     else()
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libmimalloc.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libmimalloc.a")
     endif()
 else ()
     find_package(mimalloc REQUIRED)
-    target_link_libraries(${target_name} PRIVATE mimalloc)
+    target_link_libraries(${bun} PRIVATE mimalloc)
 endif()
 
 if (USE_CUSTOM_ZSTD)
     include_directories(src/deps/zstd/include)
     if (WIN32)
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/zstd.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/zstd.lib")
     else()
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libzstd.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libzstd.a")
     endif()
 else ()
     find_package(zstd CONFIG REQUIRED)
-    target_link_libraries(${target_name} PRIVATE zstd::libzstd)
+    target_link_libraries(${bun} PRIVATE zstd::libzstd)
 endif()
 
 if (USE_CUSTOM_CARES)
     include_directories(src/deps/c-ares/include)
     if (WIN32)
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/cares.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/cares.lib")
     else()
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libcares.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libcares.a")
     endif()
 else ()
     find_package(c-ares CONFIG REQUIRED)
-    target_link_libraries(${target_name} PRIVATE c-ares::cares)
+    target_link_libraries(${bun} PRIVATE c-ares::cares)
 endif()
 
 
 if (USE_CUSTOM_BASE64)
     include_directories(src/deps/base64/include)
     if (WIN32)
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/base64.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/base64.lib")
     else()
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libbase64.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libbase64.a")
     endif()
 else ()
     find_package(base64 REQUIRED)
@@ -557,37 +583,37 @@ endif()
 if (NOT WIN32)
     if (USE_CUSTOM_TINYCC)
         if (WIN32)
-            target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/tcc.lib")
+            target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/tcc.lib")
         else()
-            target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/libtcc.a")
+            target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/libtcc.a")
         endif()
     else ()
         find_package(tinycc REQUIRED)
-        target_link_libraries(${target_name} PRIVATE tinycc::tinycc)
+        target_link_libraries(${bun} PRIVATE tinycc::tinycc)
     endif()
 endif()
 
-set_property(TARGET ${target_name} PROPERTY
+set_property(TARGET ${bun} PROPERTY
     MSVC_RUNTIME_LIBRARY "MultiThreadedDLL"
 )
 
 if (USE_CUSTOM_LOLHTML)
     if (WIN32)
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/lolhtml.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/lolhtml.lib")
     else()
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/liblolhtml.a")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/liblolhtml.a")
     endif()
 else ()
     find_package(lolhtml REQUIRED)
-    target_link_libraries(${target_name} PRIVATE lolhtml::lolhtml)
+    target_link_libraries(${bun} PRIVATE lolhtml::lolhtml)
 endif()
 
 if (WIN32)
     if (USE_CUSTOM_LIBUV)
-        target_link_libraries(${target_name} PRIVATE "${BUN_LIB_DIR}/uv.lib")
+        target_link_libraries(${bun} PRIVATE "${BUN_DEPS_DIR}/uv.lib")
     else ()
         find_package(libuv CONFIG REQUIRED )
-        target_link_libraries(${target_name} PRIVATE $<IF:$<TARGET_EXISTS:libuv::uv_a>,libuv::uv_a,libuv::uv>)
+        target_link_libraries(${bun} PRIVATE $<IF:$<TARGET_EXISTS:libuv::uv_a>,libuv::uv_a,libuv::uv>)
     endif()
 
 endif()
@@ -596,9 +622,9 @@ if (USE_STATIC_SQLITE)
     add_library(sqlite3 STATIC src/bun.js/bindings/sqlite/sqlite3.c)
     target_include_directories(sqlite3 PUBLIC src/bun.js/bindings/sqlite)
     target_link_libraries(bun PRIVATE sqlite3)
-    target_compile_definitions(${target_name} PRIVATE "LAZY_LOAD_SQLITE=0")
+    target_compile_definitions(${bun} PRIVATE "LAZY_LOAD_SQLITE=0")
 else()
-    target_compile_definitions(${target_name} PRIVATE "LAZY_LOAD_SQLITE=1")
+    target_compile_definitions(${bun} PRIVATE "LAZY_LOAD_SQLITE=1")
 endif()
 
 
@@ -608,13 +634,13 @@ endif()
 
 
 if (NOT MSVC)
-    target_link_libraries(${target_name} PRIVATE "${WEBKIT_DIR}/lib/libWTF.a")
-    target_link_libraries(${target_name} PRIVATE "${WEBKIT_DIR}/lib/libJavaScriptCore.a")
-    target_link_libraries(${target_name} PRIVATE "${WEBKIT_DIR}/lib/libbmalloc.a")
+    target_link_libraries(${bun} PRIVATE "${WEBKIT_DIR}/lib/libWTF.a")
+    target_link_libraries(${bun} PRIVATE "${WEBKIT_DIR}/lib/libJavaScriptCore.a")
+    target_link_libraries(${bun} PRIVATE "${WEBKIT_DIR}/lib/libbmalloc.a")
 else()
 
-    target_link_libraries(${target_name} PRIVATE "${WEBKIT_DIR}/lib/WTF.lib")
-    target_link_libraries(${target_name} PRIVATE "${WEBKIT_DIR}/lib/JavaScriptCore.lib")
+    target_link_libraries(${bun} PRIVATE "${WEBKIT_DIR}/lib/WTF.lib")
+    target_link_libraries(${bun} PRIVATE "${WEBKIT_DIR}/lib/JavaScriptCore.lib")
 
     if (WIN32)
         string (APPEND CMAKE_CXX_FLAGS 
@@ -623,7 +649,7 @@ else()
         string (APPEND CMAKE_FLAGS 
             " /external:anglebrackets /Gs- /Zi"
         )
-        set_target_properties(${target_name} PROPERTIES LINK_FLAGS " /SUBSYSTEM:CONSOLE /STACK:4194304,2097152")
+        set_target_properties(${bun} PROPERTIES LINK_FLAGS " /SUBSYSTEM:CONSOLE /STACK:4194304,2097152")
     endif()
     
     if (DEFINED ENV{VCPKG_ROOT})
@@ -632,14 +658,14 @@ else()
 
     # include_directories(C:/Users/windo/Build/WebKit/WebKitBuild/WTF/DerivedSources)
     # include_directories(C:/Users/windo/Build/WebKit/WebKitBuild/WTF/Headers)
-    file(COPY C:/Users/windo/Code/WebKit/WebKitBuild/cmakeconfig.h DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/src/bun.js/bindings)  
+    file(COPY C:/Users/windo/Code/WebKit/WebKitBuild/cmakeconfig.h DESTINATION ${BUN_SRC}/bun.js/bindings)  
     
 
     include_directories(C:/Users/windo/Code/WebKit/WebKitLibraries/win/include)
     link_directories(C:/Users/windo/Code/WebKit/WebKitLibraries/win/lib64)
-    target_link_directories(${target_name} PUBLIC ${ICU_LIBRARY})
+    target_link_directories(${bun} PUBLIC ${ICU_LIBRARY})
     
     
-    target_link_libraries(${target_name} PUBLIC icuuc icudt icutu icuio icuin icutest)
-    target_link_libraries(${target_name} PUBLIC winmm ws2_32 bcrypt ntdll kernel32 shell32 shlwapi advapi32 vcruntime ucrt legacy_stdio_definitions)
+    target_link_libraries(${bun} PUBLIC icuuc icudt icutu icuio icuin icutest)
+    target_link_libraries(${bun} PUBLIC winmm ws2_32 bcrypt ntdll kernel32 shell32 shlwapi advapi32 vcruntime ucrt legacy_stdio_definitions)
 endif()
\ No newline at end of file
diff --git a/build.zig b/build.zig
index 85e4e94d4..dfba69c32 100644
--- a/build.zig
+++ b/build.zig
@@ -171,6 +171,8 @@ pub fn build_(b: *Build) !void {
     // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
     optimize = b.standardOptimizeOption(.{});
 
+    const cmake_generated_directory = b.option([]const u8, "generated-files", "Set the generated files (CMake's BUN_WORKDIR)") orelse "./";
+
     var output_dir_buf = std.mem.zeroes([4096]u8);
     var bin_label = if (optimize == std.builtin.OptimizeMode.Debug) "packages/debug-bun-" else "packages/bun-";
 
@@ -319,6 +321,10 @@ pub fn build_(b: *Build) !void {
 
         obj.addOptions("build_options", actual_build_options.step(b));
 
+        obj.addModule("generated-classes", b.createModule(.{
+            .source_file = .{ .path = b.fmt("{s}/generated-classes/ZigGeneratedClasses.zig", .{cmake_generated_directory}) },
+        }));
+
         obj.linkLibC();
 
         obj.strip = false;
diff --git a/src/bun.js/api/JSBundler.classes.ts b/src/bun.js/api/JSBundler.classes.ts
index 09412b55c..664502a34 100644
--- a/src/bun.js/api/JSBundler.classes.ts
+++ b/src/bun.js/api/JSBundler.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/api/bun.classes.ts b/src/bun.js/api/bun.classes.ts
index 36f48f790..32ea56b92 100644
--- a/src/bun.js/api/bun.classes.ts
+++ b/src/bun.js/api/bun.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/api/crypto.classes.ts b/src/bun.js/api/crypto.classes.ts
index 471e87702..8262b5751 100644
--- a/src/bun.js/api/crypto.classes.ts
+++ b/src/bun.js/api/crypto.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 const names = ["SHA1", "MD5", "MD4", "SHA224", "SHA512", "SHA384", "SHA256", "SHA512_256"];
 const named = names.map(name => {
diff --git a/src/bun.js/api/ffi.classes.ts b/src/bun.js/api/ffi.classes.ts
index 0a146b22e..a0708ac85 100644
--- a/src/bun.js/api/ffi.classes.ts
+++ b/src/bun.js/api/ffi.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/api/filesystem_router.classes.ts b/src/bun.js/api/filesystem_router.classes.ts
index 9af94047c..4c331f7de 100644
--- a/src/bun.js/api/filesystem_router.classes.ts
+++ b/src/bun.js/api/filesystem_router.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/api/html_rewriter.classes.ts b/src/bun.js/api/html_rewriter.classes.ts
index f904f6f29..a00c20b7e 100644
--- a/src/bun.js/api/html_rewriter.classes.ts
+++ b/src/bun.js/api/html_rewriter.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/api/server.classes.ts b/src/bun.js/api/server.classes.ts
index 81ec30988..236e5188c 100644
--- a/src/bun.js/api/server.classes.ts
+++ b/src/bun.js/api/server.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 function generate(name) {
   return define({
diff --git a/src/bun.js/api/sockets.classes.ts b/src/bun.js/api/sockets.classes.ts
index 2a17ca39d..c99abf655 100644
--- a/src/bun.js/api/sockets.classes.ts
+++ b/src/bun.js/api/sockets.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 function generate(ssl) {
   return define({
diff --git a/src/bun.js/bindings/JSSink.cpp b/src/bun.js/bindings/JSSink.cpp
deleted file mode 100644
index 42f341b0c..000000000
--- a/src/bun.js/bindings/JSSink.cpp
+++ /dev/null
@@ -1,2221 +0,0 @@
-
-// AUTO-GENERATED FILE. DO NOT EDIT.
-// Generated by 'make generate-sink'
-// To regenerate this file, run:
-//
-//   make generate-sink
-//
-#include "root.h"
-#include "headers.h"
-#include "BunClientData.h"
-
-#include "JSSink.h"
-#include "AsyncContextFrame.h"
-
-#include "ActiveDOMObject.h"
-#include "ExtendedDOMClientIsoSubspaces.h"
-#include "ExtendedDOMIsoSubspaces.h"
-#include "IDLTypes.h"
-// #include "JSBlob.h"
-#include "JSDOMAttribute.h"
-#include "JSDOMBinding.h"
-#include "JSDOMConstructor.h"
-#include "JSDOMConvertBase.h"
-#include "JSDOMConvertInterface.h"
-#include "JSDOMConvertStrings.h"
-#include "JSDOMExceptionHandling.h"
-#include "JSDOMGlobalObject.h"
-#include "JSDOMGlobalObjectInlines.h"
-#include "JSDOMOperation.h"
-#include "JSDOMWrapperCache.h"
-#include "ScriptExecutionContext.h"
-#include "WebCoreJSClientData.h"
-#include "JavaScriptCore/FunctionPrototype.h"
-#include "JavaScriptCore/HeapAnalyzer.h"
-
-#include "JavaScriptCore/JSDestructibleObjectHeapCellType.h"
-#include "JavaScriptCore/SlotVisitorMacros.h"
-#include "JavaScriptCore/SubspaceInlines.h"
-#include "wtf/GetPtr.h"
-#include "wtf/PointerPreparations.h"
-#include "wtf/URL.h"
-#include "JavaScriptCore/BuiltinNames.h"
-
-#include "JSBufferEncodingType.h"
-#include "JavaScriptCore/JSBase.h"
-#if ENABLE(MEDIA_SOURCE)
-#include "BufferMediaSource.h"
-#include "JSMediaSource.h"
-#endif
-
-// #include "JavaScriptCore/JSTypedArrayViewPrototype.h"
-#include "JavaScriptCore/JSArrayBufferViewInlines.h"
-
-#include "JSReadableStream.h"
-#include "BunClientData.h"
-#include "JavaScriptCore/Weak.h"
-#include "JavaScriptCore/WeakInlines.h"
-
-
-
-namespace WebCore {
-using namespace JSC;
-
-
-
-
-
-JSC_DEFINE_HOST_FUNCTION(functionStartDirectStream, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-
-    JSC::JSValue readableStream = callFrame->argument(0);
-    JSC::JSValue onPull = callFrame->argument(1);
-    JSC::JSValue onClose = callFrame->argument(2);
-    JSC::JSValue asyncContext = callFrame->argument(3);
-
-    if (!readableStream.isObject()) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected ReadableStream"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    if (!onPull.isObject() || !onPull.isCallable()) {
-        onPull = JSC::jsUndefined();
-    } else if (!asyncContext.isUndefined()) {
-        onPull = AsyncContextFrame::create(globalObject, onPull, asyncContext);
-    }
-
-    if (!onClose.isObject() || !onClose.isCallable()) {
-        onClose = JSC::jsUndefined();
-    } else if (!asyncContext.isUndefined()) {
-        onClose = AsyncContextFrame::create(globalObject, onClose, asyncContext);
-    }
-
-
-
-     if (WebCore::JSReadableArrayBufferSinkController* ArrayBufferSinkController = JSC::jsDynamicCast<WebCore::JSReadableArrayBufferSinkController*>(callFrame->thisValue())) {
-        if (ArrayBufferSinkController->wrapped() == nullptr) {
-            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Cannot start stream with closed controller"_s));
-            return JSC::JSValue::encode(JSC::jsUndefined());
-        }
-
-        ArrayBufferSinkController->start(globalObject, readableStream, onPull, onClose);
-    }
-
-
-    else if (WebCore::JSReadableFileSinkController* FileSinkController = JSC::jsDynamicCast<WebCore::JSReadableFileSinkController*>(callFrame->thisValue())) {
-        if (FileSinkController->wrapped() == nullptr) {
-            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Cannot start stream with closed controller"_s));
-            return JSC::JSValue::encode(JSC::jsUndefined());
-        }
-
-        FileSinkController->start(globalObject, readableStream, onPull, onClose);
-    }
-
-
-    else if (WebCore::JSReadableHTTPResponseSinkController* HTTPResponseSinkController = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(callFrame->thisValue())) {
-        if (HTTPResponseSinkController->wrapped() == nullptr) {
-            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Cannot start stream with closed controller"_s));
-            return JSC::JSValue::encode(JSC::jsUndefined());
-        }
-
-        HTTPResponseSinkController->start(globalObject, readableStream, onPull, onClose);
-    }
-
-
-    else if (WebCore::JSReadableHTTPSResponseSinkController* HTTPSResponseSinkController = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(callFrame->thisValue())) {
-        if (HTTPSResponseSinkController->wrapped() == nullptr) {
-            scope.throwException(globalObject, JSC::createTypeError(globalObject, "Cannot start stream with closed controller"_s));
-            return JSC::JSValue::encode(JSC::jsUndefined());
-        }
-
-        HTTPSResponseSinkController->start(globalObject, readableStream, onPull, onClose);
-    }
-
-    else {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Unknown direct controller. This is a bug in Bun."_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::jsUndefined()));
-}
-
-
-  void JSArrayBufferSink::ref() {
-    if (!m_sinkPtr)
-      return;
-
-    m_refCount++;
-    if (m_refCount == 1) {
-      ArrayBufferSink__updateRef(m_sinkPtr, true);
-    }
-  }
-
-  void JSArrayBufferSink::unref() {
-    if (!m_sinkPtr)
-      return;
-
-      m_refCount = std::max(0, m_refCount - 1);
-      if (!m_refCount)
-      {
-        ArrayBufferSink__updateRef(m_sinkPtr, false);
-      }
-  }
-
-JSC_DEFINE_HOST_FUNCTION(ArrayBufferSink__ref, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    auto* sink = jsDynamicCast<WebCore::JSArrayBufferSink*>(callFrame->thisValue());
-    if (LIKELY(sink)) {
-        sink->ref();
-    }
-    return JSC::JSValue::encode(JSC::jsUndefined());
-
-}
-
-
-JSC_DEFINE_HOST_FUNCTION(ArrayBufferSink__unref, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    auto* sink = jsDynamicCast<WebCore::JSArrayBufferSink*>(callFrame->thisValue());
-    if (LIKELY(sink)) {
-        sink->unref();
-    }
-    return JSC::JSValue::encode(JSC::jsUndefined());
-
-}
-
-JSC_DEFINE_CUSTOM_GETTER(functionArrayBufferSink__getter, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-
-    return JSC::JSValue::encode(globalObject->ArrayBufferSink());
-}
-
-
-JSC_DECLARE_HOST_FUNCTION(JSReadableArrayBufferSinkController__close);
-JSC_DEFINE_HOST_FUNCTION(JSReadableArrayBufferSinkController__close, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSReadableArrayBufferSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableArrayBufferSinkController*>(callFrame->thisValue());
-    if (!controller) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableArrayBufferSinkController"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = controller->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    controller->detach();
-    ArrayBufferSink__close(lexicalGlobalObject, ptr);
-    return JSC::JSValue::encode(JSC::jsUndefined());
-}
-
-JSC_DECLARE_HOST_FUNCTION(JSReadableArrayBufferSinkController__end);
-JSC_DEFINE_HOST_FUNCTION(JSReadableArrayBufferSinkController__end, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSReadableArrayBufferSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableArrayBufferSinkController*>(callFrame->thisValue());
-    if (!controller) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableArrayBufferSinkController"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = controller->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    controller->detach();
-    return ArrayBufferSink__endWithSink(ptr, lexicalGlobalObject);
-}
-
-
-JSC_DECLARE_HOST_FUNCTION(ArrayBufferSink__doClose);
-JSC_DEFINE_HOST_FUNCTION(ArrayBufferSink__doClose, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSArrayBufferSink* sink = JSC::jsDynamicCast<WebCore::JSArrayBufferSink*>(callFrame->thisValue());
-    if (!sink) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected ArrayBufferSink"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = sink->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    sink->detach();
-    ArrayBufferSink__close(lexicalGlobalObject, ptr);
-    return JSC::JSValue::encode(JSC::jsUndefined());
-}
-
-
-
-
-  void JSFileSink::ref() {
-    if (!m_sinkPtr)
-      return;
-
-    m_refCount++;
-    if (m_refCount == 1) {
-      FileSink__updateRef(m_sinkPtr, true);
-    }
-  }
-
-  void JSFileSink::unref() {
-    if (!m_sinkPtr)
-      return;
-
-      m_refCount = std::max(0, m_refCount - 1);
-      if (!m_refCount)
-      {
-        FileSink__updateRef(m_sinkPtr, false);
-      }
-  }
-
-JSC_DEFINE_HOST_FUNCTION(FileSink__ref, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    auto* sink = jsDynamicCast<WebCore::JSFileSink*>(callFrame->thisValue());
-    if (LIKELY(sink)) {
-        sink->ref();
-    }
-    return JSC::JSValue::encode(JSC::jsUndefined());
-
-}
-
-
-JSC_DEFINE_HOST_FUNCTION(FileSink__unref, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    auto* sink = jsDynamicCast<WebCore::JSFileSink*>(callFrame->thisValue());
-    if (LIKELY(sink)) {
-        sink->unref();
-    }
-    return JSC::JSValue::encode(JSC::jsUndefined());
-
-}
-
-JSC_DEFINE_CUSTOM_GETTER(functionFileSink__getter, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-
-    return JSC::JSValue::encode(globalObject->FileSink());
-}
-
-
-JSC_DECLARE_HOST_FUNCTION(JSReadableFileSinkController__close);
-JSC_DEFINE_HOST_FUNCTION(JSReadableFileSinkController__close, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSReadableFileSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableFileSinkController*>(callFrame->thisValue());
-    if (!controller) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableFileSinkController"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = controller->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    controller->detach();
-    FileSink__close(lexicalGlobalObject, ptr);
-    return JSC::JSValue::encode(JSC::jsUndefined());
-}
-
-JSC_DECLARE_HOST_FUNCTION(JSReadableFileSinkController__end);
-JSC_DEFINE_HOST_FUNCTION(JSReadableFileSinkController__end, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSReadableFileSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableFileSinkController*>(callFrame->thisValue());
-    if (!controller) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableFileSinkController"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = controller->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    controller->detach();
-    return FileSink__endWithSink(ptr, lexicalGlobalObject);
-}
-
-
-JSC_DECLARE_HOST_FUNCTION(FileSink__doClose);
-JSC_DEFINE_HOST_FUNCTION(FileSink__doClose, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSFileSink* sink = JSC::jsDynamicCast<WebCore::JSFileSink*>(callFrame->thisValue());
-    if (!sink) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected FileSink"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = sink->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    sink->detach();
-    FileSink__close(lexicalGlobalObject, ptr);
-    return JSC::JSValue::encode(JSC::jsUndefined());
-}
-
-
-
-
-  void JSHTTPResponseSink::ref() {
-    if (!m_sinkPtr)
-      return;
-
-    m_refCount++;
-    if (m_refCount == 1) {
-      HTTPResponseSink__updateRef(m_sinkPtr, true);
-    }
-  }
-
-  void JSHTTPResponseSink::unref() {
-    if (!m_sinkPtr)
-      return;
-
-      m_refCount = std::max(0, m_refCount - 1);
-      if (!m_refCount)
-      {
-        HTTPResponseSink__updateRef(m_sinkPtr, false);
-      }
-  }
-
-JSC_DEFINE_HOST_FUNCTION(HTTPResponseSink__ref, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    auto* sink = jsDynamicCast<WebCore::JSHTTPResponseSink*>(callFrame->thisValue());
-    if (LIKELY(sink)) {
-        sink->ref();
-    }
-    return JSC::JSValue::encode(JSC::jsUndefined());
-
-}
-
-
-JSC_DEFINE_HOST_FUNCTION(HTTPResponseSink__unref, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    auto* sink = jsDynamicCast<WebCore::JSHTTPResponseSink*>(callFrame->thisValue());
-    if (LIKELY(sink)) {
-        sink->unref();
-    }
-    return JSC::JSValue::encode(JSC::jsUndefined());
-
-}
-
-JSC_DEFINE_CUSTOM_GETTER(functionHTTPResponseSink__getter, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-
-    return JSC::JSValue::encode(globalObject->HTTPResponseSink());
-}
-
-
-JSC_DECLARE_HOST_FUNCTION(JSReadableHTTPResponseSinkController__close);
-JSC_DEFINE_HOST_FUNCTION(JSReadableHTTPResponseSinkController__close, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSReadableHTTPResponseSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(callFrame->thisValue());
-    if (!controller) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableHTTPResponseSinkController"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = controller->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    controller->detach();
-    HTTPResponseSink__close(lexicalGlobalObject, ptr);
-    return JSC::JSValue::encode(JSC::jsUndefined());
-}
-
-JSC_DECLARE_HOST_FUNCTION(JSReadableHTTPResponseSinkController__end);
-JSC_DEFINE_HOST_FUNCTION(JSReadableHTTPResponseSinkController__end, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSReadableHTTPResponseSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(callFrame->thisValue());
-    if (!controller) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableHTTPResponseSinkController"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = controller->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    controller->detach();
-    return HTTPResponseSink__endWithSink(ptr, lexicalGlobalObject);
-}
-
-
-JSC_DECLARE_HOST_FUNCTION(HTTPResponseSink__doClose);
-JSC_DEFINE_HOST_FUNCTION(HTTPResponseSink__doClose, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSHTTPResponseSink* sink = JSC::jsDynamicCast<WebCore::JSHTTPResponseSink*>(callFrame->thisValue());
-    if (!sink) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected HTTPResponseSink"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = sink->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    sink->detach();
-    HTTPResponseSink__close(lexicalGlobalObject, ptr);
-    return JSC::JSValue::encode(JSC::jsUndefined());
-}
-
-
-
-
-  void JSHTTPSResponseSink::ref() {
-    if (!m_sinkPtr)
-      return;
-
-    m_refCount++;
-    if (m_refCount == 1) {
-      HTTPSResponseSink__updateRef(m_sinkPtr, true);
-    }
-  }
-
-  void JSHTTPSResponseSink::unref() {
-    if (!m_sinkPtr)
-      return;
-
-      m_refCount = std::max(0, m_refCount - 1);
-      if (!m_refCount)
-      {
-        HTTPSResponseSink__updateRef(m_sinkPtr, false);
-      }
-  }
-
-JSC_DEFINE_HOST_FUNCTION(HTTPSResponseSink__ref, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    auto* sink = jsDynamicCast<WebCore::JSHTTPSResponseSink*>(callFrame->thisValue());
-    if (LIKELY(sink)) {
-        sink->ref();
-    }
-    return JSC::JSValue::encode(JSC::jsUndefined());
-
-}
-
-
-JSC_DEFINE_HOST_FUNCTION(HTTPSResponseSink__unref, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    auto* sink = jsDynamicCast<WebCore::JSHTTPSResponseSink*>(callFrame->thisValue());
-    if (LIKELY(sink)) {
-        sink->unref();
-    }
-    return JSC::JSValue::encode(JSC::jsUndefined());
-
-}
-
-JSC_DEFINE_CUSTOM_GETTER(functionHTTPSResponseSink__getter, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
-{
-    auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-
-    return JSC::JSValue::encode(globalObject->HTTPSResponseSink());
-}
-
-
-JSC_DECLARE_HOST_FUNCTION(JSReadableHTTPSResponseSinkController__close);
-JSC_DEFINE_HOST_FUNCTION(JSReadableHTTPSResponseSinkController__close, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSReadableHTTPSResponseSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(callFrame->thisValue());
-    if (!controller) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableHTTPSResponseSinkController"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = controller->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    controller->detach();
-    HTTPSResponseSink__close(lexicalGlobalObject, ptr);
-    return JSC::JSValue::encode(JSC::jsUndefined());
-}
-
-JSC_DECLARE_HOST_FUNCTION(JSReadableHTTPSResponseSinkController__end);
-JSC_DEFINE_HOST_FUNCTION(JSReadableHTTPSResponseSinkController__end, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSReadableHTTPSResponseSinkController* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(callFrame->thisValue());
-    if (!controller) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected JSReadableHTTPSResponseSinkController"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = controller->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    controller->detach();
-    return HTTPSResponseSink__endWithSink(ptr, lexicalGlobalObject);
-}
-
-
-JSC_DECLARE_HOST_FUNCTION(HTTPSResponseSink__doClose);
-JSC_DEFINE_HOST_FUNCTION(HTTPSResponseSink__doClose, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
-{
-    
-    auto& vm = lexicalGlobalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    WebCore::JSHTTPSResponseSink* sink = JSC::jsDynamicCast<WebCore::JSHTTPSResponseSink*>(callFrame->thisValue());
-    if (!sink) {
-        scope.throwException(globalObject, JSC::createTypeError(globalObject, "Expected HTTPSResponseSink"_s));
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    void *ptr = sink->wrapped();
-    if (ptr == nullptr) {
-        return JSC::JSValue::encode(JSC::jsUndefined());
-    }
-
-    sink->detach();
-    HTTPSResponseSink__close(lexicalGlobalObject, ptr);
-    return JSC::JSValue::encode(JSC::jsUndefined());
-}
-
-
-
-#include "JSSinkLookupTable.h"
-  
-/* Source for JSArrayBufferSinkPrototypeTableValues.lut.h
-@begin JSArrayBufferSinkPrototypeTable
-  close      ArrayBufferSink__doClose         ReadOnly|DontDelete|Function 0
-  flush      ArrayBufferSink__flush           ReadOnly|DontDelete|Function 1
-  end        ArrayBufferSink__end             ReadOnly|DontDelete|Function 0
-  start      ArrayBufferSink__start           ReadOnly|DontDelete|Function 1
-  write      ArrayBufferSink__write           ReadOnly|DontDelete|Function 1
-  ref        ArrayBufferSink__ref             ReadOnly|DontDelete|Function 0
-  unref      ArrayBufferSink__unref           ReadOnly|DontDelete|Function 0
-@end
-*/
-
-
-/* Source for JSReadableArrayBufferSinkControllerPrototypeTableValues.lut.h
-@begin JSReadableArrayBufferSinkControllerPrototypeTable
-  close        JSReadableArrayBufferSinkController__close      ReadOnly|DontDelete|Function 0
-  flush        ArrayBufferSink__flush                          ReadOnly|DontDelete|Function 1
-  end          JSReadableArrayBufferSinkController__end        ReadOnly|DontDelete|Function 0
-  start        ArrayBufferSink__start                          ReadOnly|DontDelete|Function 1
-  write        ArrayBufferSink__write                          ReadOnly|DontDelete|Function 1
-@end
-*/
-
-  
-/* Source for JSFileSinkPrototypeTableValues.lut.h
-@begin JSFileSinkPrototypeTable
-  close      FileSink__doClose         ReadOnly|DontDelete|Function 0
-  flush      FileSink__flush           ReadOnly|DontDelete|Function 1
-  end        FileSink__end             ReadOnly|DontDelete|Function 0
-  start      FileSink__start           ReadOnly|DontDelete|Function 1
-  write      FileSink__write           ReadOnly|DontDelete|Function 1
-  ref        FileSink__ref             ReadOnly|DontDelete|Function 0
-  unref      FileSink__unref           ReadOnly|DontDelete|Function 0
-@end
-*/
-
-
-/* Source for JSReadableFileSinkControllerPrototypeTableValues.lut.h
-@begin JSReadableFileSinkControllerPrototypeTable
-  close        JSReadableFileSinkController__close      ReadOnly|DontDelete|Function 0
-  flush        FileSink__flush                          ReadOnly|DontDelete|Function 1
-  end          JSReadableFileSinkController__end        ReadOnly|DontDelete|Function 0
-  start        FileSink__start                          ReadOnly|DontDelete|Function 1
-  write        FileSink__write                          ReadOnly|DontDelete|Function 1
-@end
-*/
-
-  
-/* Source for JSHTTPResponseSinkPrototypeTableValues.lut.h
-@begin JSHTTPResponseSinkPrototypeTable
-  close      HTTPResponseSink__doClose         ReadOnly|DontDelete|Function 0
-  flush      HTTPResponseSink__flush           ReadOnly|DontDelete|Function 1
-  end        HTTPResponseSink__end             ReadOnly|DontDelete|Function 0
-  start      HTTPResponseSink__start           ReadOnly|DontDelete|Function 1
-  write      HTTPResponseSink__write           ReadOnly|DontDelete|Function 1
-  ref        HTTPResponseSink__ref             ReadOnly|DontDelete|Function 0
-  unref      HTTPResponseSink__unref           ReadOnly|DontDelete|Function 0
-@end
-*/
-
-
-/* Source for JSReadableHTTPResponseSinkControllerPrototypeTableValues.lut.h
-@begin JSReadableHTTPResponseSinkControllerPrototypeTable
-  close        JSReadableHTTPResponseSinkController__close      ReadOnly|DontDelete|Function 0
-  flush        HTTPResponseSink__flush                          ReadOnly|DontDelete|Function 1
-  end          JSReadableHTTPResponseSinkController__end        ReadOnly|DontDelete|Function 0
-  start        HTTPResponseSink__start                          ReadOnly|DontDelete|Function 1
-  write        HTTPResponseSink__write                          ReadOnly|DontDelete|Function 1
-@end
-*/
-
-  
-/* Source for JSHTTPSResponseSinkPrototypeTableValues.lut.h
-@begin JSHTTPSResponseSinkPrototypeTable
-  close      HTTPSResponseSink__doClose         ReadOnly|DontDelete|Function 0
-  flush      HTTPSResponseSink__flush           ReadOnly|DontDelete|Function 1
-  end        HTTPSResponseSink__end             ReadOnly|DontDelete|Function 0
-  start      HTTPSResponseSink__start           ReadOnly|DontDelete|Function 1
-  write      HTTPSResponseSink__write           ReadOnly|DontDelete|Function 1
-  ref        HTTPSResponseSink__ref             ReadOnly|DontDelete|Function 0
-  unref      HTTPSResponseSink__unref           ReadOnly|DontDelete|Function 0
-@end
-*/
-
-
-/* Source for JSReadableHTTPSResponseSinkControllerPrototypeTableValues.lut.h
-@begin JSReadableHTTPSResponseSinkControllerPrototypeTable
-  close        JSReadableHTTPSResponseSinkController__close      ReadOnly|DontDelete|Function 0
-  flush        HTTPSResponseSink__flush                          ReadOnly|DontDelete|Function 1
-  end          JSReadableHTTPSResponseSinkController__end        ReadOnly|DontDelete|Function 0
-  start        HTTPSResponseSink__start                          ReadOnly|DontDelete|Function 1
-  write        HTTPSResponseSink__write                          ReadOnly|DontDelete|Function 1
-@end
-*/
-
-  
-#pragma mark - ArrayBufferSink
-
-class JSArrayBufferSinkPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSArrayBufferSinkPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSArrayBufferSinkPrototype* ptr = new (NotNull, JSC::allocateCell<JSArrayBufferSinkPrototype>(vm)) JSArrayBufferSinkPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSArrayBufferSinkPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSArrayBufferSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSArrayBufferSinkPrototype, JSArrayBufferSinkPrototype::Base);
-
-class JSReadableArrayBufferSinkControllerPrototype final : public JSC::JSNonFinalObject {
-    public:
-        using Base = JSC::JSNonFinalObject;
-    
-        static JSReadableArrayBufferSinkControllerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-        {
-            JSReadableArrayBufferSinkControllerPrototype* ptr = new (NotNull, JSC::allocateCell<JSReadableArrayBufferSinkControllerPrototype>(vm)) JSReadableArrayBufferSinkControllerPrototype(vm, globalObject, structure);
-            ptr->finishCreation(vm, globalObject);
-            return ptr;
-        }
-    
-        DECLARE_INFO;
-        template<typename CellType, JSC::SubspaceAccess>
-        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-        {
-            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableArrayBufferSinkControllerPrototype, Base);
-            return &vm.plainObjectSpace();
-        }
-        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-        {
-            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-        }
-    
-    private:
-        JSReadableArrayBufferSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-            : Base(vm, structure)
-        {
-        }
-    
-        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-    };
-    STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableArrayBufferSinkControllerPrototype, JSReadableArrayBufferSinkControllerPrototype::Base);
-
-const ClassInfo JSArrayBufferSinkPrototype::s_info = { "ArrayBufferSink"_s, &Base::s_info, &JSArrayBufferSinkPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSArrayBufferSinkPrototype) };
-const ClassInfo JSArrayBufferSink::s_info = { "ArrayBufferSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSArrayBufferSink) };
-const ClassInfo JSArrayBufferSinkConstructor::s_info = { "ArrayBufferSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSArrayBufferSinkConstructor) };
-
-
-const ClassInfo JSReadableArrayBufferSinkControllerPrototype::s_info = { "ReadableArrayBufferSinkController"_s, &Base::s_info, &JSReadableArrayBufferSinkControllerPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSReadableArrayBufferSinkControllerPrototype) };
-const ClassInfo JSReadableArrayBufferSinkController::s_info = { "ReadableArrayBufferSinkController"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSReadableArrayBufferSinkController) };
-
-JSArrayBufferSink::~JSArrayBufferSink()
-{
-    if (m_sinkPtr) {
-        ArrayBufferSink__finalize(m_sinkPtr);
-    }
-}
-
-
-JSReadableArrayBufferSinkController::~JSReadableArrayBufferSinkController()
-{
-    if (m_sinkPtr) {
-        ArrayBufferSink__finalize(m_sinkPtr);
-    }
-}
-
-JSObject* JSArrayBufferSink::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
-{
-    return JSArrayBufferSinkPrototype::create(vm, &globalObject, JSArrayBufferSinkPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
-}
-
-JSObject* JSReadableArrayBufferSinkController::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
-{
-    return JSReadableArrayBufferSinkControllerPrototype::create(vm, &globalObject, JSReadableArrayBufferSinkControllerPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
-}
-
-void JSReadableArrayBufferSinkController::detach() {
-    m_sinkPtr = nullptr;
-    m_onPull.clear();
-
-    auto readableStream = m_weakReadableStream.get();
-    auto onClose = m_onClose.get();
-    
-    if (readableStream && onClose) {
-        auto callData = JSC::getCallData(onClose);
-        if(callData.type != JSC::CallData::Type::None) {
-            JSC::JSGlobalObject *globalObject = this->globalObject();
-            JSC::MarkedArgumentBuffer arguments;
-            arguments.append(readableStream);
-            arguments.append(jsUndefined());
-            call(globalObject, onClose, callData, JSC::jsUndefined(), arguments);
-        }
-    }
-
-    m_onClose.clear();
-    m_weakReadableStream.clear();
-}
-
-
-JSArrayBufferSinkConstructor* JSArrayBufferSinkConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSObject* prototype)
-{
-    JSArrayBufferSinkConstructor* ptr = new (NotNull, JSC::allocateCell<JSArrayBufferSinkConstructor>(vm)) JSArrayBufferSinkConstructor(vm, structure, ArrayBufferSink__construct);
-    ptr->finishCreation(vm, globalObject, prototype);
-    return ptr;
-}
-
-JSArrayBufferSink* JSArrayBufferSink::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
-{
-    JSArrayBufferSink* ptr = new (NotNull, JSC::allocateCell<JSArrayBufferSink>(vm)) JSArrayBufferSink(vm, structure, sinkPtr);
-    ptr->finishCreation(vm);
-    return ptr;
-}
-
-JSReadableArrayBufferSinkController* JSReadableArrayBufferSinkController::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
-{
-    JSReadableArrayBufferSinkController* ptr = new (NotNull, JSC::allocateCell<JSReadableArrayBufferSinkController>(vm)) JSReadableArrayBufferSinkController(vm, structure, sinkPtr);
-    ptr->finishCreation(vm);
-    return ptr;
-}
-
-void JSArrayBufferSinkConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-    initializeProperties(vm, globalObject, prototype);
-}
-
-JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSArrayBufferSinkConstructor::construct(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) {
-    return ArrayBufferSink__construct(globalObject, callFrame);
-}
-
-
-void JSArrayBufferSinkConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
-{
-    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSString* nameString = jsNontrivialString(vm, "ArrayBufferSink"_s);
-    m_originalName.set(vm, this, nameString);
-    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-}
-
-void JSArrayBufferSinkPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSArrayBufferSink::info(), JSArrayBufferSinkPrototypeTableValues, *this);
-    putDirect(vm, JSC::Identifier::fromString(vm, "sinkId"_s), JSC::jsNumber(JSArrayBufferSink::Sink), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-
-void JSReadableArrayBufferSinkControllerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSReadableArrayBufferSinkController::info(), JSReadableArrayBufferSinkControllerPrototypeTableValues, *this);
-    putDirect(vm, JSC::Identifier::fromString(vm, "sinkId"_s), JSC::jsNumber(JSArrayBufferSink::Sink), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-
-void JSArrayBufferSink::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-}
-
-void JSReadableArrayBufferSinkController::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-}
-
-
-void JSArrayBufferSink::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
-{
-    auto* thisObject = jsCast<JSArrayBufferSink*>(cell);
-    if (void* wrapped = thisObject->wrapped()) {
-        analyzer.setWrappedObjectForCell(cell, wrapped);
-        // if (thisObject->scriptExecutionContext())
-        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
-    }
-    Base::analyzeHeap(cell, analyzer);
-}
-
-void JSReadableArrayBufferSinkController::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
-{
-    auto* thisObject = jsCast<JSReadableArrayBufferSinkController*>(cell);
-    if (void* wrapped = thisObject->wrapped()) {
-        analyzer.setWrappedObjectForCell(cell, wrapped);
-        // if (thisObject->scriptExecutionContext())
-        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
-    }
-    Base::analyzeHeap(cell, analyzer);
-}
-
-
-template<typename Visitor>
-void JSReadableArrayBufferSinkController::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    JSReadableArrayBufferSinkController* thisObject = jsCast<JSReadableArrayBufferSinkController*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-    visitor.append(thisObject->m_onPull);
-    visitor.append(thisObject->m_onClose);
-    void* ptr = thisObject->m_sinkPtr;
-    if (ptr)
-      visitor.addOpaqueRoot(ptr);
-}
-
-DEFINE_VISIT_CHILDREN(JSReadableArrayBufferSinkController);
-
-template<typename Visitor>
-void JSArrayBufferSink::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    JSArrayBufferSink* thisObject = jsCast<JSArrayBufferSink*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-    void* ptr = thisObject->m_sinkPtr;
-    if (ptr)
-      visitor.addOpaqueRoot(ptr);
-}
-
-DEFINE_VISIT_CHILDREN(JSArrayBufferSink);
-
-
-void JSReadableArrayBufferSinkController::start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSValue onPull, JSC::JSValue onClose) {
-    this->m_weakReadableStream = JSC::Weak<JSC::JSObject>(readableStream.getObject());
-    this->m_onPull.set(globalObject->vm(), this, onPull);
-    this->m_onClose.set(globalObject->vm(), this, onClose);
-}
-
-void JSArrayBufferSink::destroy(JSCell* cell)
-{
-    static_cast<JSArrayBufferSink*>(cell)->JSArrayBufferSink::~JSArrayBufferSink();
-}
-
-
-void JSReadableArrayBufferSinkController::destroy(JSCell* cell)
-{
-    static_cast<JSReadableArrayBufferSinkController*>(cell)->JSReadableArrayBufferSinkController::~JSReadableArrayBufferSinkController();
-}
-
-
-
-#pragma mark - FileSink
-
-class JSFileSinkPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSFileSinkPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSFileSinkPrototype* ptr = new (NotNull, JSC::allocateCell<JSFileSinkPrototype>(vm)) JSFileSinkPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFileSinkPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSFileSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFileSinkPrototype, JSFileSinkPrototype::Base);
-
-class JSReadableFileSinkControllerPrototype final : public JSC::JSNonFinalObject {
-    public:
-        using Base = JSC::JSNonFinalObject;
-    
-        static JSReadableFileSinkControllerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-        {
-            JSReadableFileSinkControllerPrototype* ptr = new (NotNull, JSC::allocateCell<JSReadableFileSinkControllerPrototype>(vm)) JSReadableFileSinkControllerPrototype(vm, globalObject, structure);
-            ptr->finishCreation(vm, globalObject);
-            return ptr;
-        }
-    
-        DECLARE_INFO;
-        template<typename CellType, JSC::SubspaceAccess>
-        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-        {
-            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableFileSinkControllerPrototype, Base);
-            return &vm.plainObjectSpace();
-        }
-        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-        {
-            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-        }
-    
-    private:
-        JSReadableFileSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-            : Base(vm, structure)
-        {
-        }
-    
-        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-    };
-    STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableFileSinkControllerPrototype, JSReadableFileSinkControllerPrototype::Base);
-
-const ClassInfo JSFileSinkPrototype::s_info = { "FileSink"_s, &Base::s_info, &JSFileSinkPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSFileSinkPrototype) };
-const ClassInfo JSFileSink::s_info = { "FileSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFileSink) };
-const ClassInfo JSFileSinkConstructor::s_info = { "FileSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFileSinkConstructor) };
-
-
-const ClassInfo JSReadableFileSinkControllerPrototype::s_info = { "ReadableFileSinkController"_s, &Base::s_info, &JSReadableFileSinkControllerPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSReadableFileSinkControllerPrototype) };
-const ClassInfo JSReadableFileSinkController::s_info = { "ReadableFileSinkController"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSReadableFileSinkController) };
-
-JSFileSink::~JSFileSink()
-{
-    if (m_sinkPtr) {
-        FileSink__finalize(m_sinkPtr);
-    }
-}
-
-
-JSReadableFileSinkController::~JSReadableFileSinkController()
-{
-    if (m_sinkPtr) {
-        FileSink__finalize(m_sinkPtr);
-    }
-}
-
-JSObject* JSFileSink::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
-{
-    return JSFileSinkPrototype::create(vm, &globalObject, JSFileSinkPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
-}
-
-JSObject* JSReadableFileSinkController::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
-{
-    return JSReadableFileSinkControllerPrototype::create(vm, &globalObject, JSReadableFileSinkControllerPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
-}
-
-void JSReadableFileSinkController::detach() {
-    m_sinkPtr = nullptr;
-    m_onPull.clear();
-
-    auto readableStream = m_weakReadableStream.get();
-    auto onClose = m_onClose.get();
-    
-    if (readableStream && onClose) {
-        auto callData = JSC::getCallData(onClose);
-        if(callData.type != JSC::CallData::Type::None) {
-            JSC::JSGlobalObject *globalObject = this->globalObject();
-            JSC::MarkedArgumentBuffer arguments;
-            arguments.append(readableStream);
-            arguments.append(jsUndefined());
-            call(globalObject, onClose, callData, JSC::jsUndefined(), arguments);
-        }
-    }
-
-    m_onClose.clear();
-    m_weakReadableStream.clear();
-}
-
-
-JSFileSinkConstructor* JSFileSinkConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSObject* prototype)
-{
-    JSFileSinkConstructor* ptr = new (NotNull, JSC::allocateCell<JSFileSinkConstructor>(vm)) JSFileSinkConstructor(vm, structure, FileSink__construct);
-    ptr->finishCreation(vm, globalObject, prototype);
-    return ptr;
-}
-
-JSFileSink* JSFileSink::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
-{
-    JSFileSink* ptr = new (NotNull, JSC::allocateCell<JSFileSink>(vm)) JSFileSink(vm, structure, sinkPtr);
-    ptr->finishCreation(vm);
-    return ptr;
-}
-
-JSReadableFileSinkController* JSReadableFileSinkController::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
-{
-    JSReadableFileSinkController* ptr = new (NotNull, JSC::allocateCell<JSReadableFileSinkController>(vm)) JSReadableFileSinkController(vm, structure, sinkPtr);
-    ptr->finishCreation(vm);
-    return ptr;
-}
-
-void JSFileSinkConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-    initializeProperties(vm, globalObject, prototype);
-}
-
-JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSFileSinkConstructor::construct(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) {
-    return FileSink__construct(globalObject, callFrame);
-}
-
-
-void JSFileSinkConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
-{
-    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSString* nameString = jsNontrivialString(vm, "FileSink"_s);
-    m_originalName.set(vm, this, nameString);
-    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-}
-
-void JSFileSinkPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSFileSink::info(), JSFileSinkPrototypeTableValues, *this);
-    putDirect(vm, JSC::Identifier::fromString(vm, "sinkId"_s), JSC::jsNumber(JSFileSink::Sink), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-
-void JSReadableFileSinkControllerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSReadableFileSinkController::info(), JSReadableFileSinkControllerPrototypeTableValues, *this);
-    putDirect(vm, JSC::Identifier::fromString(vm, "sinkId"_s), JSC::jsNumber(JSFileSink::Sink), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-
-void JSFileSink::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-}
-
-void JSReadableFileSinkController::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-}
-
-
-void JSFileSink::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
-{
-    auto* thisObject = jsCast<JSFileSink*>(cell);
-    if (void* wrapped = thisObject->wrapped()) {
-        analyzer.setWrappedObjectForCell(cell, wrapped);
-        // if (thisObject->scriptExecutionContext())
-        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
-    }
-    Base::analyzeHeap(cell, analyzer);
-}
-
-void JSReadableFileSinkController::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
-{
-    auto* thisObject = jsCast<JSReadableFileSinkController*>(cell);
-    if (void* wrapped = thisObject->wrapped()) {
-        analyzer.setWrappedObjectForCell(cell, wrapped);
-        // if (thisObject->scriptExecutionContext())
-        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
-    }
-    Base::analyzeHeap(cell, analyzer);
-}
-
-
-template<typename Visitor>
-void JSReadableFileSinkController::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    JSReadableFileSinkController* thisObject = jsCast<JSReadableFileSinkController*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-    visitor.append(thisObject->m_onPull);
-    visitor.append(thisObject->m_onClose);
-    void* ptr = thisObject->m_sinkPtr;
-    if (ptr)
-      visitor.addOpaqueRoot(ptr);
-}
-
-DEFINE_VISIT_CHILDREN(JSReadableFileSinkController);
-
-template<typename Visitor>
-void JSFileSink::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    JSFileSink* thisObject = jsCast<JSFileSink*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-    void* ptr = thisObject->m_sinkPtr;
-    if (ptr)
-      visitor.addOpaqueRoot(ptr);
-}
-
-DEFINE_VISIT_CHILDREN(JSFileSink);
-
-
-void JSReadableFileSinkController::start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSValue onPull, JSC::JSValue onClose) {
-    this->m_weakReadableStream = JSC::Weak<JSC::JSObject>(readableStream.getObject());
-    this->m_onPull.set(globalObject->vm(), this, onPull);
-    this->m_onClose.set(globalObject->vm(), this, onClose);
-}
-
-void JSFileSink::destroy(JSCell* cell)
-{
-    static_cast<JSFileSink*>(cell)->JSFileSink::~JSFileSink();
-}
-
-
-void JSReadableFileSinkController::destroy(JSCell* cell)
-{
-    static_cast<JSReadableFileSinkController*>(cell)->JSReadableFileSinkController::~JSReadableFileSinkController();
-}
-
-
-
-#pragma mark - HTTPResponseSink
-
-class JSHTTPResponseSinkPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSHTTPResponseSinkPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSHTTPResponseSinkPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTTPResponseSinkPrototype>(vm)) JSHTTPResponseSinkPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPResponseSinkPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSHTTPResponseSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPResponseSinkPrototype, JSHTTPResponseSinkPrototype::Base);
-
-class JSReadableHTTPResponseSinkControllerPrototype final : public JSC::JSNonFinalObject {
-    public:
-        using Base = JSC::JSNonFinalObject;
-    
-        static JSReadableHTTPResponseSinkControllerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-        {
-            JSReadableHTTPResponseSinkControllerPrototype* ptr = new (NotNull, JSC::allocateCell<JSReadableHTTPResponseSinkControllerPrototype>(vm)) JSReadableHTTPResponseSinkControllerPrototype(vm, globalObject, structure);
-            ptr->finishCreation(vm, globalObject);
-            return ptr;
-        }
-    
-        DECLARE_INFO;
-        template<typename CellType, JSC::SubspaceAccess>
-        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-        {
-            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableHTTPResponseSinkControllerPrototype, Base);
-            return &vm.plainObjectSpace();
-        }
-        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-        {
-            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-        }
-    
-    private:
-        JSReadableHTTPResponseSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-            : Base(vm, structure)
-        {
-        }
-    
-        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-    };
-    STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableHTTPResponseSinkControllerPrototype, JSReadableHTTPResponseSinkControllerPrototype::Base);
-
-const ClassInfo JSHTTPResponseSinkPrototype::s_info = { "HTTPResponseSink"_s, &Base::s_info, &JSHTTPResponseSinkPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSHTTPResponseSinkPrototype) };
-const ClassInfo JSHTTPResponseSink::s_info = { "HTTPResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPResponseSink) };
-const ClassInfo JSHTTPResponseSinkConstructor::s_info = { "HTTPResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPResponseSinkConstructor) };
-
-
-const ClassInfo JSReadableHTTPResponseSinkControllerPrototype::s_info = { "ReadableHTTPResponseSinkController"_s, &Base::s_info, &JSReadableHTTPResponseSinkControllerPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSReadableHTTPResponseSinkControllerPrototype) };
-const ClassInfo JSReadableHTTPResponseSinkController::s_info = { "ReadableHTTPResponseSinkController"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSReadableHTTPResponseSinkController) };
-
-JSHTTPResponseSink::~JSHTTPResponseSink()
-{
-    if (m_sinkPtr) {
-        HTTPResponseSink__finalize(m_sinkPtr);
-    }
-}
-
-
-JSReadableHTTPResponseSinkController::~JSReadableHTTPResponseSinkController()
-{
-    if (m_sinkPtr) {
-        HTTPResponseSink__finalize(m_sinkPtr);
-    }
-}
-
-JSObject* JSHTTPResponseSink::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
-{
-    return JSHTTPResponseSinkPrototype::create(vm, &globalObject, JSHTTPResponseSinkPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
-}
-
-JSObject* JSReadableHTTPResponseSinkController::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
-{
-    return JSReadableHTTPResponseSinkControllerPrototype::create(vm, &globalObject, JSReadableHTTPResponseSinkControllerPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
-}
-
-void JSReadableHTTPResponseSinkController::detach() {
-    m_sinkPtr = nullptr;
-    m_onPull.clear();
-
-    auto readableStream = m_weakReadableStream.get();
-    auto onClose = m_onClose.get();
-    
-    if (readableStream && onClose) {
-        auto callData = JSC::getCallData(onClose);
-        if(callData.type != JSC::CallData::Type::None) {
-            JSC::JSGlobalObject *globalObject = this->globalObject();
-            JSC::MarkedArgumentBuffer arguments;
-            arguments.append(readableStream);
-            arguments.append(jsUndefined());
-            call(globalObject, onClose, callData, JSC::jsUndefined(), arguments);
-        }
-    }
-
-    m_onClose.clear();
-    m_weakReadableStream.clear();
-}
-
-
-JSHTTPResponseSinkConstructor* JSHTTPResponseSinkConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSObject* prototype)
-{
-    JSHTTPResponseSinkConstructor* ptr = new (NotNull, JSC::allocateCell<JSHTTPResponseSinkConstructor>(vm)) JSHTTPResponseSinkConstructor(vm, structure, HTTPResponseSink__construct);
-    ptr->finishCreation(vm, globalObject, prototype);
-    return ptr;
-}
-
-JSHTTPResponseSink* JSHTTPResponseSink::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
-{
-    JSHTTPResponseSink* ptr = new (NotNull, JSC::allocateCell<JSHTTPResponseSink>(vm)) JSHTTPResponseSink(vm, structure, sinkPtr);
-    ptr->finishCreation(vm);
-    return ptr;
-}
-
-JSReadableHTTPResponseSinkController* JSReadableHTTPResponseSinkController::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
-{
-    JSReadableHTTPResponseSinkController* ptr = new (NotNull, JSC::allocateCell<JSReadableHTTPResponseSinkController>(vm)) JSReadableHTTPResponseSinkController(vm, structure, sinkPtr);
-    ptr->finishCreation(vm);
-    return ptr;
-}
-
-void JSHTTPResponseSinkConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-    initializeProperties(vm, globalObject, prototype);
-}
-
-JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSHTTPResponseSinkConstructor::construct(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) {
-    return HTTPResponseSink__construct(globalObject, callFrame);
-}
-
-
-void JSHTTPResponseSinkConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
-{
-    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSString* nameString = jsNontrivialString(vm, "HTTPResponseSink"_s);
-    m_originalName.set(vm, this, nameString);
-    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-}
-
-void JSHTTPResponseSinkPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSHTTPResponseSink::info(), JSHTTPResponseSinkPrototypeTableValues, *this);
-    putDirect(vm, JSC::Identifier::fromString(vm, "sinkId"_s), JSC::jsNumber(JSHTTPResponseSink::Sink), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-
-void JSReadableHTTPResponseSinkControllerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSReadableHTTPResponseSinkController::info(), JSReadableHTTPResponseSinkControllerPrototypeTableValues, *this);
-    putDirect(vm, JSC::Identifier::fromString(vm, "sinkId"_s), JSC::jsNumber(JSHTTPResponseSink::Sink), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-
-void JSHTTPResponseSink::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-}
-
-void JSReadableHTTPResponseSinkController::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-}
-
-
-void JSHTTPResponseSink::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
-{
-    auto* thisObject = jsCast<JSHTTPResponseSink*>(cell);
-    if (void* wrapped = thisObject->wrapped()) {
-        analyzer.setWrappedObjectForCell(cell, wrapped);
-        // if (thisObject->scriptExecutionContext())
-        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
-    }
-    Base::analyzeHeap(cell, analyzer);
-}
-
-void JSReadableHTTPResponseSinkController::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
-{
-    auto* thisObject = jsCast<JSReadableHTTPResponseSinkController*>(cell);
-    if (void* wrapped = thisObject->wrapped()) {
-        analyzer.setWrappedObjectForCell(cell, wrapped);
-        // if (thisObject->scriptExecutionContext())
-        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
-    }
-    Base::analyzeHeap(cell, analyzer);
-}
-
-
-template<typename Visitor>
-void JSReadableHTTPResponseSinkController::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    JSReadableHTTPResponseSinkController* thisObject = jsCast<JSReadableHTTPResponseSinkController*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-    visitor.append(thisObject->m_onPull);
-    visitor.append(thisObject->m_onClose);
-    void* ptr = thisObject->m_sinkPtr;
-    if (ptr)
-      visitor.addOpaqueRoot(ptr);
-}
-
-DEFINE_VISIT_CHILDREN(JSReadableHTTPResponseSinkController);
-
-template<typename Visitor>
-void JSHTTPResponseSink::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    JSHTTPResponseSink* thisObject = jsCast<JSHTTPResponseSink*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-    void* ptr = thisObject->m_sinkPtr;
-    if (ptr)
-      visitor.addOpaqueRoot(ptr);
-}
-
-DEFINE_VISIT_CHILDREN(JSHTTPResponseSink);
-
-
-void JSReadableHTTPResponseSinkController::start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSValue onPull, JSC::JSValue onClose) {
-    this->m_weakReadableStream = JSC::Weak<JSC::JSObject>(readableStream.getObject());
-    this->m_onPull.set(globalObject->vm(), this, onPull);
-    this->m_onClose.set(globalObject->vm(), this, onClose);
-}
-
-void JSHTTPResponseSink::destroy(JSCell* cell)
-{
-    static_cast<JSHTTPResponseSink*>(cell)->JSHTTPResponseSink::~JSHTTPResponseSink();
-}
-
-
-void JSReadableHTTPResponseSinkController::destroy(JSCell* cell)
-{
-    static_cast<JSReadableHTTPResponseSinkController*>(cell)->JSReadableHTTPResponseSinkController::~JSReadableHTTPResponseSinkController();
-}
-
-
-
-#pragma mark - HTTPSResponseSink
-
-class JSHTTPSResponseSinkPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSHTTPSResponseSinkPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSHTTPSResponseSinkPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTTPSResponseSinkPrototype>(vm)) JSHTTPSResponseSinkPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPSResponseSinkPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSHTTPSResponseSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPSResponseSinkPrototype, JSHTTPSResponseSinkPrototype::Base);
-
-class JSReadableHTTPSResponseSinkControllerPrototype final : public JSC::JSNonFinalObject {
-    public:
-        using Base = JSC::JSNonFinalObject;
-    
-        static JSReadableHTTPSResponseSinkControllerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-        {
-            JSReadableHTTPSResponseSinkControllerPrototype* ptr = new (NotNull, JSC::allocateCell<JSReadableHTTPSResponseSinkControllerPrototype>(vm)) JSReadableHTTPSResponseSinkControllerPrototype(vm, globalObject, structure);
-            ptr->finishCreation(vm, globalObject);
-            return ptr;
-        }
-    
-        DECLARE_INFO;
-        template<typename CellType, JSC::SubspaceAccess>
-        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-        {
-            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableHTTPSResponseSinkControllerPrototype, Base);
-            return &vm.plainObjectSpace();
-        }
-        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-        {
-            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-        }
-    
-    private:
-        JSReadableHTTPSResponseSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-            : Base(vm, structure)
-        {
-        }
-    
-        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-    };
-    STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSReadableHTTPSResponseSinkControllerPrototype, JSReadableHTTPSResponseSinkControllerPrototype::Base);
-
-const ClassInfo JSHTTPSResponseSinkPrototype::s_info = { "HTTPSResponseSink"_s, &Base::s_info, &JSHTTPSResponseSinkPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSHTTPSResponseSinkPrototype) };
-const ClassInfo JSHTTPSResponseSink::s_info = { "HTTPSResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPSResponseSink) };
-const ClassInfo JSHTTPSResponseSinkConstructor::s_info = { "HTTPSResponseSink"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPSResponseSinkConstructor) };
-
-
-const ClassInfo JSReadableHTTPSResponseSinkControllerPrototype::s_info = { "ReadableHTTPSResponseSinkController"_s, &Base::s_info, &JSReadableHTTPSResponseSinkControllerPrototypeTable, nullptr, CREATE_METHOD_TABLE(JSReadableHTTPSResponseSinkControllerPrototype) };
-const ClassInfo JSReadableHTTPSResponseSinkController::s_info = { "ReadableHTTPSResponseSinkController"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSReadableHTTPSResponseSinkController) };
-
-JSHTTPSResponseSink::~JSHTTPSResponseSink()
-{
-    if (m_sinkPtr) {
-        HTTPSResponseSink__finalize(m_sinkPtr);
-    }
-}
-
-
-JSReadableHTTPSResponseSinkController::~JSReadableHTTPSResponseSinkController()
-{
-    if (m_sinkPtr) {
-        HTTPSResponseSink__finalize(m_sinkPtr);
-    }
-}
-
-JSObject* JSHTTPSResponseSink::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
-{
-    return JSHTTPSResponseSinkPrototype::create(vm, &globalObject, JSHTTPSResponseSinkPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
-}
-
-JSObject* JSReadableHTTPSResponseSinkController::createPrototype(VM& vm, JSDOMGlobalObject& globalObject)
-{
-    return JSReadableHTTPSResponseSinkControllerPrototype::create(vm, &globalObject, JSReadableHTTPSResponseSinkControllerPrototype::createStructure(vm, &globalObject, globalObject.objectPrototype()));
-}
-
-void JSReadableHTTPSResponseSinkController::detach() {
-    m_sinkPtr = nullptr;
-    m_onPull.clear();
-
-    auto readableStream = m_weakReadableStream.get();
-    auto onClose = m_onClose.get();
-    
-    if (readableStream && onClose) {
-        auto callData = JSC::getCallData(onClose);
-        if(callData.type != JSC::CallData::Type::None) {
-            JSC::JSGlobalObject *globalObject = this->globalObject();
-            JSC::MarkedArgumentBuffer arguments;
-            arguments.append(readableStream);
-            arguments.append(jsUndefined());
-            call(globalObject, onClose, callData, JSC::jsUndefined(), arguments);
-        }
-    }
-
-    m_onClose.clear();
-    m_weakReadableStream.clear();
-}
-
-
-JSHTTPSResponseSinkConstructor* JSHTTPSResponseSinkConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSObject* prototype)
-{
-    JSHTTPSResponseSinkConstructor* ptr = new (NotNull, JSC::allocateCell<JSHTTPSResponseSinkConstructor>(vm)) JSHTTPSResponseSinkConstructor(vm, structure, HTTPSResponseSink__construct);
-    ptr->finishCreation(vm, globalObject, prototype);
-    return ptr;
-}
-
-JSHTTPSResponseSink* JSHTTPSResponseSink::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
-{
-    JSHTTPSResponseSink* ptr = new (NotNull, JSC::allocateCell<JSHTTPSResponseSink>(vm)) JSHTTPSResponseSink(vm, structure, sinkPtr);
-    ptr->finishCreation(vm);
-    return ptr;
-}
-
-JSReadableHTTPSResponseSinkController* JSReadableHTTPSResponseSinkController::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
-{
-    JSReadableHTTPSResponseSinkController* ptr = new (NotNull, JSC::allocateCell<JSReadableHTTPSResponseSinkController>(vm)) JSReadableHTTPSResponseSinkController(vm, structure, sinkPtr);
-    ptr->finishCreation(vm);
-    return ptr;
-}
-
-void JSHTTPSResponseSinkConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-    initializeProperties(vm, globalObject, prototype);
-}
-
-JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSHTTPSResponseSinkConstructor::construct(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) {
-    return HTTPSResponseSink__construct(globalObject, callFrame);
-}
-
-
-void JSHTTPSResponseSinkConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
-{
-    putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSString* nameString = jsNontrivialString(vm, "HTTPSResponseSink"_s);
-    m_originalName.set(vm, this, nameString);
-    putDirect(vm, vm.propertyNames->name, nameString, JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-}
-
-void JSHTTPSResponseSinkPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSHTTPSResponseSink::info(), JSHTTPSResponseSinkPrototypeTableValues, *this);
-    putDirect(vm, JSC::Identifier::fromString(vm, "sinkId"_s), JSC::jsNumber(JSHTTPSResponseSink::Sink), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-
-void JSReadableHTTPSResponseSinkControllerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
-{
-    Base::finishCreation(vm);
-    reifyStaticProperties(vm, JSReadableHTTPSResponseSinkController::info(), JSReadableHTTPSResponseSinkControllerPrototypeTableValues, *this);
-    putDirect(vm, JSC::Identifier::fromString(vm, "sinkId"_s), JSC::jsNumber(JSHTTPSResponseSink::Sink), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
-    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
-}
-
-void JSHTTPSResponseSink::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-}
-
-void JSReadableHTTPSResponseSinkController::finishCreation(VM& vm)
-{
-    Base::finishCreation(vm);
-    ASSERT(inherits(info()));
-}
-
-
-void JSHTTPSResponseSink::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
-{
-    auto* thisObject = jsCast<JSHTTPSResponseSink*>(cell);
-    if (void* wrapped = thisObject->wrapped()) {
-        analyzer.setWrappedObjectForCell(cell, wrapped);
-        // if (thisObject->scriptExecutionContext())
-        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
-    }
-    Base::analyzeHeap(cell, analyzer);
-}
-
-void JSReadableHTTPSResponseSinkController::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
-{
-    auto* thisObject = jsCast<JSReadableHTTPSResponseSinkController*>(cell);
-    if (void* wrapped = thisObject->wrapped()) {
-        analyzer.setWrappedObjectForCell(cell, wrapped);
-        // if (thisObject->scriptExecutionContext())
-        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
-    }
-    Base::analyzeHeap(cell, analyzer);
-}
-
-
-template<typename Visitor>
-void JSReadableHTTPSResponseSinkController::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    JSReadableHTTPSResponseSinkController* thisObject = jsCast<JSReadableHTTPSResponseSinkController*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-    visitor.append(thisObject->m_onPull);
-    visitor.append(thisObject->m_onClose);
-    void* ptr = thisObject->m_sinkPtr;
-    if (ptr)
-      visitor.addOpaqueRoot(ptr);
-}
-
-DEFINE_VISIT_CHILDREN(JSReadableHTTPSResponseSinkController);
-
-template<typename Visitor>
-void JSHTTPSResponseSink::visitChildrenImpl(JSCell* cell, Visitor& visitor)
-{
-    JSHTTPSResponseSink* thisObject = jsCast<JSHTTPSResponseSink*>(cell);
-    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    Base::visitChildren(thisObject, visitor);
-    void* ptr = thisObject->m_sinkPtr;
-    if (ptr)
-      visitor.addOpaqueRoot(ptr);
-}
-
-DEFINE_VISIT_CHILDREN(JSHTTPSResponseSink);
-
-
-void JSReadableHTTPSResponseSinkController::start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSValue onPull, JSC::JSValue onClose) {
-    this->m_weakReadableStream = JSC::Weak<JSC::JSObject>(readableStream.getObject());
-    this->m_onPull.set(globalObject->vm(), this, onPull);
-    this->m_onClose.set(globalObject->vm(), this, onClose);
-}
-
-void JSHTTPSResponseSink::destroy(JSCell* cell)
-{
-    static_cast<JSHTTPSResponseSink*>(cell)->JSHTTPSResponseSink::~JSHTTPSResponseSink();
-}
-
-
-void JSReadableHTTPSResponseSinkController::destroy(JSCell* cell)
-{
-    static_cast<JSReadableHTTPSResponseSinkController*>(cell)->JSReadableHTTPSResponseSinkController::~JSReadableHTTPSResponseSinkController();
-}
-
-
-
-  JSObject* createJSSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, SinkID sinkID)
-  {
-      switch (sinkID) {
-    
-    case ArrayBufferSink:
-        return JSArrayBufferSinkPrototype::create(vm, globalObject, JSArrayBufferSinkPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
-
-    case FileSink:
-        return JSFileSinkPrototype::create(vm, globalObject, JSFileSinkPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
-
-    case HTTPResponseSink:
-        return JSHTTPResponseSinkPrototype::create(vm, globalObject, JSHTTPResponseSinkPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
-
-    case HTTPSResponseSink:
-        return JSHTTPSResponseSinkPrototype::create(vm, globalObject, JSHTTPSResponseSinkPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
-
-default: 
-    RELEASE_ASSERT_NOT_REACHED();
-    }
-}
-JSObject* createJSSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, SinkID sinkID)
-{
-    switch (sinkID) {
-  
-  case ArrayBufferSink:
-      return JSReadableArrayBufferSinkControllerPrototype::create(vm, globalObject, JSReadableArrayBufferSinkControllerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
-
-  case FileSink:
-      return JSReadableFileSinkControllerPrototype::create(vm, globalObject, JSReadableFileSinkControllerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
-
-  case HTTPResponseSink:
-      return JSReadableHTTPResponseSinkControllerPrototype::create(vm, globalObject, JSReadableHTTPResponseSinkControllerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
-
-  case HTTPSResponseSink:
-      return JSReadableHTTPSResponseSinkControllerPrototype::create(vm, globalObject, JSReadableHTTPSResponseSinkControllerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
-
-default: 
-  RELEASE_ASSERT_NOT_REACHED();
-  }
-}
-Structure* createJSSinkControllerStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, SinkID sinkID)
-{
-    switch (sinkID) {
-  
-  case ArrayBufferSink: {
-    auto* prototype = createJSSinkControllerPrototype(vm, globalObject, sinkID);
-    return JSReadableArrayBufferSinkController::createStructure(vm, globalObject, prototype);
-  }
-
-  case FileSink: {
-    auto* prototype = createJSSinkControllerPrototype(vm, globalObject, sinkID);
-    return JSReadableFileSinkController::createStructure(vm, globalObject, prototype);
-  }
-
-  case HTTPResponseSink: {
-    auto* prototype = createJSSinkControllerPrototype(vm, globalObject, sinkID);
-    return JSReadableHTTPResponseSinkController::createStructure(vm, globalObject, prototype);
-  }
-
-  case HTTPSResponseSink: {
-    auto* prototype = createJSSinkControllerPrototype(vm, globalObject, sinkID);
-    return JSReadableHTTPSResponseSinkController::createStructure(vm, globalObject, prototype);
-  }
-
-default:
-    RELEASE_ASSERT_NOT_REACHED();
-  }
-}
-} // namespace WebCore
-
-
-extern "C" JSC__JSValue ArrayBufferSink__createObject(JSC__JSGlobalObject* arg0, void* sinkPtr)
-{
-    auto& vm = arg0->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
-    JSC::Structure* structure = globalObject->ArrayBufferSinkStructure();
-    return JSC::JSValue::encode(WebCore::JSArrayBufferSink::create(vm, globalObject, structure, sinkPtr));
-}
-
-extern "C" void* ArrayBufferSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1)
-{
-    JSC::VM& vm = WebCore::getVM(arg0);
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JSArrayBufferSink*>(JSC::JSValue::decode(JSValue1)))
-        return sink->wrapped();
-
-    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableArrayBufferSinkController*>(JSC::JSValue::decode(JSValue1)))
-        return controller->wrapped();
-
-    return nullptr;
-}
-
-extern "C" void ArrayBufferSink__detachPtr(JSC__JSValue JSValue0)
-{
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JSArrayBufferSink*>(JSC::JSValue::decode(JSValue0))) {
-        sink->detach();
-        return;
-    }
-        
-
-    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableArrayBufferSinkController*>(JSC::JSValue::decode(JSValue0))) {
-        controller->detach();
-        return;
-    }
-}
-
-extern "C" JSC__JSValue ArrayBufferSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, void **controllerValue)
-{
-    auto& vm = arg0->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
-
-    JSC::Structure* structure = WebCore::getDOMStructure<WebCore::JSReadableArrayBufferSinkController>(vm, *globalObject);
-    WebCore::JSReadableArrayBufferSinkController *controller = WebCore::JSReadableArrayBufferSinkController::create(vm, globalObject, structure, sinkPtr);
-    *controllerValue = reinterpret_cast<void*>(JSC::JSValue::encode(controller));
-    return globalObject->assignToStream(JSC::JSValue::decode(stream), controller);
-}
-
-extern "C" void ArrayBufferSink__onReady(JSC__JSValue controllerValue, JSC__JSValue amt, JSC__JSValue offset)
-{
-    WebCore::JSReadableArrayBufferSinkController* controller = JSC::jsCast<WebCore::JSReadableArrayBufferSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
-
-    JSC::JSValue function = controller->m_onPull.get();
-    if (!function)
-        return;
-    JSC::JSGlobalObject *globalObject = controller->globalObject();
-
-    JSC::MarkedArgumentBuffer arguments;
-    arguments.append(controller);
-    arguments.append(JSC::JSValue::decode(amt));
-    arguments.append(JSC::JSValue::decode(offset));
-
-    AsyncContextFrame::call(globalObject, function, JSC::jsUndefined(), arguments);
-}
-
-extern "C" void ArrayBufferSink__onStart(JSC__JSValue controllerValue)
-{
-
-}
-
-extern "C" void ArrayBufferSink__onClose(JSC__JSValue controllerValue, JSC__JSValue reason)
-{
-    WebCore::JSReadableArrayBufferSinkController* controller = JSC::jsCast<WebCore::JSReadableArrayBufferSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
-
-    JSC::JSValue function = controller->m_onClose.get();
-    if (!function)
-        return;
-    // only call close once
-    controller->m_onClose.clear();
-    JSC::JSGlobalObject* globalObject = controller->globalObject();
-
-    JSC::MarkedArgumentBuffer arguments;
-    auto readableStream = controller->m_weakReadableStream.get();
-    arguments.append(readableStream ? readableStream : JSC::jsUndefined());
-
-    arguments.append(JSC::JSValue::decode(reason));
-    AsyncContextFrame::call(globalObject, function, JSC::jsUndefined(), arguments);
-}
-
-
-extern "C" JSC__JSValue FileSink__createObject(JSC__JSGlobalObject* arg0, void* sinkPtr)
-{
-    auto& vm = arg0->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
-    JSC::Structure* structure = globalObject->FileSinkStructure();
-    return JSC::JSValue::encode(WebCore::JSFileSink::create(vm, globalObject, structure, sinkPtr));
-}
-
-extern "C" void* FileSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1)
-{
-    JSC::VM& vm = WebCore::getVM(arg0);
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JSFileSink*>(JSC::JSValue::decode(JSValue1)))
-        return sink->wrapped();
-
-    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableFileSinkController*>(JSC::JSValue::decode(JSValue1)))
-        return controller->wrapped();
-
-    return nullptr;
-}
-
-extern "C" void FileSink__detachPtr(JSC__JSValue JSValue0)
-{
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JSFileSink*>(JSC::JSValue::decode(JSValue0))) {
-        sink->detach();
-        return;
-    }
-        
-
-    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableFileSinkController*>(JSC::JSValue::decode(JSValue0))) {
-        controller->detach();
-        return;
-    }
-}
-
-extern "C" JSC__JSValue FileSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, void **controllerValue)
-{
-    auto& vm = arg0->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
-
-    JSC::Structure* structure = WebCore::getDOMStructure<WebCore::JSReadableFileSinkController>(vm, *globalObject);
-    WebCore::JSReadableFileSinkController *controller = WebCore::JSReadableFileSinkController::create(vm, globalObject, structure, sinkPtr);
-    *controllerValue = reinterpret_cast<void*>(JSC::JSValue::encode(controller));
-    return globalObject->assignToStream(JSC::JSValue::decode(stream), controller);
-}
-
-extern "C" void FileSink__onReady(JSC__JSValue controllerValue, JSC__JSValue amt, JSC__JSValue offset)
-{
-    WebCore::JSReadableFileSinkController* controller = JSC::jsCast<WebCore::JSReadableFileSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
-
-    JSC::JSValue function = controller->m_onPull.get();
-    if (!function)
-        return;
-    JSC::JSGlobalObject *globalObject = controller->globalObject();
-
-    JSC::MarkedArgumentBuffer arguments;
-    arguments.append(controller);
-    arguments.append(JSC::JSValue::decode(amt));
-    arguments.append(JSC::JSValue::decode(offset));
-
-    AsyncContextFrame::call(globalObject, function, JSC::jsUndefined(), arguments);
-}
-
-extern "C" void FileSink__onStart(JSC__JSValue controllerValue)
-{
-
-}
-
-extern "C" void FileSink__onClose(JSC__JSValue controllerValue, JSC__JSValue reason)
-{
-    WebCore::JSReadableFileSinkController* controller = JSC::jsCast<WebCore::JSReadableFileSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
-
-    JSC::JSValue function = controller->m_onClose.get();
-    if (!function)
-        return;
-    // only call close once
-    controller->m_onClose.clear();
-    JSC::JSGlobalObject* globalObject = controller->globalObject();
-
-    JSC::MarkedArgumentBuffer arguments;
-    auto readableStream = controller->m_weakReadableStream.get();
-    arguments.append(readableStream ? readableStream : JSC::jsUndefined());
-
-    arguments.append(JSC::JSValue::decode(reason));
-    AsyncContextFrame::call(globalObject, function, JSC::jsUndefined(), arguments);
-}
-
-
-extern "C" JSC__JSValue HTTPResponseSink__createObject(JSC__JSGlobalObject* arg0, void* sinkPtr)
-{
-    auto& vm = arg0->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
-    JSC::Structure* structure = globalObject->HTTPResponseSinkStructure();
-    return JSC::JSValue::encode(WebCore::JSHTTPResponseSink::create(vm, globalObject, structure, sinkPtr));
-}
-
-extern "C" void* HTTPResponseSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1)
-{
-    JSC::VM& vm = WebCore::getVM(arg0);
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JSHTTPResponseSink*>(JSC::JSValue::decode(JSValue1)))
-        return sink->wrapped();
-
-    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(JSC::JSValue::decode(JSValue1)))
-        return controller->wrapped();
-
-    return nullptr;
-}
-
-extern "C" void HTTPResponseSink__detachPtr(JSC__JSValue JSValue0)
-{
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JSHTTPResponseSink*>(JSC::JSValue::decode(JSValue0))) {
-        sink->detach();
-        return;
-    }
-        
-
-    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPResponseSinkController*>(JSC::JSValue::decode(JSValue0))) {
-        controller->detach();
-        return;
-    }
-}
-
-extern "C" JSC__JSValue HTTPResponseSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, void **controllerValue)
-{
-    auto& vm = arg0->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
-
-    JSC::Structure* structure = WebCore::getDOMStructure<WebCore::JSReadableHTTPResponseSinkController>(vm, *globalObject);
-    WebCore::JSReadableHTTPResponseSinkController *controller = WebCore::JSReadableHTTPResponseSinkController::create(vm, globalObject, structure, sinkPtr);
-    *controllerValue = reinterpret_cast<void*>(JSC::JSValue::encode(controller));
-    return globalObject->assignToStream(JSC::JSValue::decode(stream), controller);
-}
-
-extern "C" void HTTPResponseSink__onReady(JSC__JSValue controllerValue, JSC__JSValue amt, JSC__JSValue offset)
-{
-    WebCore::JSReadableHTTPResponseSinkController* controller = JSC::jsCast<WebCore::JSReadableHTTPResponseSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
-
-    JSC::JSValue function = controller->m_onPull.get();
-    if (!function)
-        return;
-    JSC::JSGlobalObject *globalObject = controller->globalObject();
-
-    JSC::MarkedArgumentBuffer arguments;
-    arguments.append(controller);
-    arguments.append(JSC::JSValue::decode(amt));
-    arguments.append(JSC::JSValue::decode(offset));
-
-    AsyncContextFrame::call(globalObject, function, JSC::jsUndefined(), arguments);
-}
-
-extern "C" void HTTPResponseSink__onStart(JSC__JSValue controllerValue)
-{
-
-}
-
-extern "C" void HTTPResponseSink__onClose(JSC__JSValue controllerValue, JSC__JSValue reason)
-{
-    WebCore::JSReadableHTTPResponseSinkController* controller = JSC::jsCast<WebCore::JSReadableHTTPResponseSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
-
-    JSC::JSValue function = controller->m_onClose.get();
-    if (!function)
-        return;
-    // only call close once
-    controller->m_onClose.clear();
-    JSC::JSGlobalObject* globalObject = controller->globalObject();
-
-    JSC::MarkedArgumentBuffer arguments;
-    auto readableStream = controller->m_weakReadableStream.get();
-    arguments.append(readableStream ? readableStream : JSC::jsUndefined());
-
-    arguments.append(JSC::JSValue::decode(reason));
-    AsyncContextFrame::call(globalObject, function, JSC::jsUndefined(), arguments);
-}
-
-
-extern "C" JSC__JSValue HTTPSResponseSink__createObject(JSC__JSGlobalObject* arg0, void* sinkPtr)
-{
-    auto& vm = arg0->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
-    JSC::Structure* structure = globalObject->HTTPSResponseSinkStructure();
-    return JSC::JSValue::encode(WebCore::JSHTTPSResponseSink::create(vm, globalObject, structure, sinkPtr));
-}
-
-extern "C" void* HTTPSResponseSink__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1)
-{
-    JSC::VM& vm = WebCore::getVM(arg0);
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JSHTTPSResponseSink*>(JSC::JSValue::decode(JSValue1)))
-        return sink->wrapped();
-
-    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(JSC::JSValue::decode(JSValue1)))
-        return controller->wrapped();
-
-    return nullptr;
-}
-
-extern "C" void HTTPSResponseSink__detachPtr(JSC__JSValue JSValue0)
-{
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JSHTTPSResponseSink*>(JSC::JSValue::decode(JSValue0))) {
-        sink->detach();
-        return;
-    }
-        
-
-    if (auto* controller = JSC::jsDynamicCast<WebCore::JSReadableHTTPSResponseSinkController*>(JSC::JSValue::decode(JSValue0))) {
-        controller->detach();
-        return;
-    }
-}
-
-extern "C" JSC__JSValue HTTPSResponseSink__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, void **controllerValue)
-{
-    auto& vm = arg0->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
-
-    JSC::Structure* structure = WebCore::getDOMStructure<WebCore::JSReadableHTTPSResponseSinkController>(vm, *globalObject);
-    WebCore::JSReadableHTTPSResponseSinkController *controller = WebCore::JSReadableHTTPSResponseSinkController::create(vm, globalObject, structure, sinkPtr);
-    *controllerValue = reinterpret_cast<void*>(JSC::JSValue::encode(controller));
-    return globalObject->assignToStream(JSC::JSValue::decode(stream), controller);
-}
-
-extern "C" void HTTPSResponseSink__onReady(JSC__JSValue controllerValue, JSC__JSValue amt, JSC__JSValue offset)
-{
-    WebCore::JSReadableHTTPSResponseSinkController* controller = JSC::jsCast<WebCore::JSReadableHTTPSResponseSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
-
-    JSC::JSValue function = controller->m_onPull.get();
-    if (!function)
-        return;
-    JSC::JSGlobalObject *globalObject = controller->globalObject();
-
-    JSC::MarkedArgumentBuffer arguments;
-    arguments.append(controller);
-    arguments.append(JSC::JSValue::decode(amt));
-    arguments.append(JSC::JSValue::decode(offset));
-
-    AsyncContextFrame::call(globalObject, function, JSC::jsUndefined(), arguments);
-}
-
-extern "C" void HTTPSResponseSink__onStart(JSC__JSValue controllerValue)
-{
-
-}
-
-extern "C" void HTTPSResponseSink__onClose(JSC__JSValue controllerValue, JSC__JSValue reason)
-{
-    WebCore::JSReadableHTTPSResponseSinkController* controller = JSC::jsCast<WebCore::JSReadableHTTPSResponseSinkController*>(JSC::JSValue::decode(controllerValue).getObject());
-
-    JSC::JSValue function = controller->m_onClose.get();
-    if (!function)
-        return;
-    // only call close once
-    controller->m_onClose.clear();
-    JSC::JSGlobalObject* globalObject = controller->globalObject();
-
-    JSC::MarkedArgumentBuffer arguments;
-    auto readableStream = controller->m_weakReadableStream.get();
-    arguments.append(readableStream ? readableStream : JSC::jsUndefined());
-
-    arguments.append(JSC::JSValue::decode(reason));
-    AsyncContextFrame::call(globalObject, function, JSC::jsUndefined(), arguments);
-}
-
diff --git a/src/bun.js/bindings/JSSink.h b/src/bun.js/bindings/JSSink.h
deleted file mode 100644
index f68b84e44..000000000
--- a/src/bun.js/bindings/JSSink.h
+++ /dev/null
@@ -1,632 +0,0 @@
-
-// AUTO-GENERATED FILE. DO NOT EDIT.
-// Generated by 'make generate-sink'
-//
-#pragma once
-
-#include "root.h"
-
-#include "JSDOMWrapper.h"
-#include "wtf/NeverDestroyed.h"
-
-#include "Sink.h"
-
-extern "C" bool JSSink_isSink(JSC::JSGlobalObject*, JSC::EncodedJSValue);
-
-namespace WebCore {
-using namespace JSC;
-
-JSC_DECLARE_HOST_FUNCTION(functionStartDirectStream);
-class JSArrayBufferSinkConstructor final : public JSC::InternalFunction {                                                                                                     
-        public:                                                                                                                                                                     
-            using Base = JSC::InternalFunction;                                                                                                                                     
-            static JSArrayBufferSinkConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
-            static constexpr SinkID Sink = SinkID::ArrayBufferSink;
-                                                                                                                                                                                    
-            static constexpr unsigned StructureFlags = Base::StructureFlags;                                                                                                        
-            static constexpr bool needsDestruction = false;                                                                                                                         
-                                                                                                                                                                                    
-            DECLARE_EXPORT_INFO;                                                                                                                                                    
-            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-            {                                                                                                                                                                       
-                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                    return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<JSArrayBufferSinkConstructor, WebCore::UseCustomHeapCellType::No>(                                                                    
-                    vm,                                                                                                                                                             
-                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },                                                                                 
-                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = std::forward<decltype(space)>(space); },                                                               
-                    [](auto& spaces) { return spaces.m_subspaceForJSSinkConstructor.get(); },                                                                                       
-                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkConstructor = std::forward<decltype(space)>(space); });                                                                    
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-            {                                                                                                                                                                       
-                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());                                                 
-            }                                                                                                                                                                       
-            void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);   
-            
-            
-            // Must be defined for each specialization class.
-            static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-                                                                                                                                                               
-        private:                                                                                                                                                                    
-            JSArrayBufferSinkConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
-                : Base(vm, structure, nativeFunction, nativeFunction)                                                                                                               
-                                                                                                                                                                                    
-            {                                                                                                                                                                       
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);                                                     
-        };                                                                                                                                                                          
-                                                                                                                                                                                    
-        class JSArrayBufferSink final : public JSC::JSDestructibleObject {                                                                                                              
-        public:                                                                                                                                                                     
-            using Base = JSC::JSDestructibleObject;                                                                                                                                 
-            static JSArrayBufferSink* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-            static constexpr SinkID Sink = SinkID::ArrayBufferSink;                                          
-                                                                                                                                                                                    
-            DECLARE_EXPORT_INFO;                                                                                                                                                    
-            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-            {                                                                                                                                                                       
-                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                    return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<JSArrayBufferSink, WebCore::UseCustomHeapCellType::No>(                                                                                 
-                    vm,                                                                                                                                                             
-                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },                                                                                            
-                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = std::forward<decltype(space)>(space); },                                                                          
-                    [](auto& spaces) { return spaces.m_subspaceForJSSink.get(); },                                                                                                  
-                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSink = std::forward<decltype(space)>(space); });                                                                               
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            static void destroy(JSC::JSCell*);                                                                                                                                      
-            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-            {                                                                                                                                                                       
-                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
-            }                       
-            
-            static JSObject* createPrototype(VM& vm, JSDOMGlobalObject& globalObject);
-                                                                                                                                                                                    
-            ~JSArrayBufferSink();                                                                                                                                                       
-                                                                                                                                                                                    
-            void* wrapped() const { return m_sinkPtr; }    
-            DECLARE_VISIT_CHILDREN;                                                                                                                         
-
-            void detach() {
-                m_sinkPtr = nullptr;
-
-            }
-
-            static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-            void ref();
-            void unref();
-                                                                                                                                                                                    
-            void* m_sinkPtr;
-            int m_refCount { 1 };
-                                                                                                                                                                                    
-            JSArrayBufferSink(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
-                : Base(vm, structure)                                                                                                                                               
-            {                                                                                                                                                                       
-                m_sinkPtr = sinkPtr;
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            void finishCreation(JSC::VM&);
-        };
-
-     
-
-        class JSReadableArrayBufferSinkController final : public JSC::JSDestructibleObject {                                                                                                              
-            public:                                                                                                                                                                     
-                using Base = JSC::JSDestructibleObject;                                                                                                                                 
-                static JSReadableArrayBufferSinkController* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-                static constexpr SinkID Sink = SinkID::ArrayBufferSink;                                          
-                                                                                                                                                                                        
-                DECLARE_EXPORT_INFO;                                                                                                                                                    
-                template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-                {                                                                                                                                                                       
-                    if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                        return nullptr;                                                                                                                                                 
-                    return WebCore::subspaceForImpl<JSReadableArrayBufferSinkController, WebCore::UseCustomHeapCellType::No>(                                                                                 
-                        vm,                                                                                                                                                             
-                        [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },                                                                                            
-                        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = std::forward<decltype(space)>(space); },                                                                          
-                        [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },                                                                                                  
-                        [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = std::forward<decltype(space)>(space); });                                                                               
-                }                                                                                                                                                                       
-                                                                                                                                                                                        
-                static void destroy(JSC::JSCell*);                                                                                                                                      
-                static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-                {                                                                                                                                                                       
-                    return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
-                }
-                static JSObject* createPrototype(VM& vm, JSDOMGlobalObject& globalObject);
-                                                                                                                                                                                        
-                ~JSReadableArrayBufferSinkController();                                                                                                                                                       
-
-
-                void* wrapped() const { return m_sinkPtr; }    
-                void detach();
-
-                void start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSValue onPull, JSC::JSValue onClose);
-                DECLARE_VISIT_CHILDREN;
-                                                                                                                                                                                        
-                static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-                void* m_sinkPtr;
-                mutable WriteBarrier<JSC::Unknown> m_onPull;
-                mutable WriteBarrier<JSC::Unknown> m_onClose;
-                mutable JSC::Weak<JSObject> m_weakReadableStream;
-                                                                                                                                                                                        
-                JSReadableArrayBufferSinkController(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
-                    : Base(vm, structure)                                                                                                                                               
-                {                                                                                                                                                                       
-                    m_sinkPtr = sinkPtr;
-                }                                                                                                                                                                       
-                                                                                                                                                                                        
-                void finishCreation(JSC::VM&);
-            };
-
-JSC_DECLARE_CUSTOM_GETTER(functionArrayBufferSink__getter);
-
-        
-class JSFileSinkConstructor final : public JSC::InternalFunction {                                                                                                     
-        public:                                                                                                                                                                     
-            using Base = JSC::InternalFunction;                                                                                                                                     
-            static JSFileSinkConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
-            static constexpr SinkID Sink = SinkID::FileSink;
-                                                                                                                                                                                    
-            static constexpr unsigned StructureFlags = Base::StructureFlags;                                                                                                        
-            static constexpr bool needsDestruction = false;                                                                                                                         
-                                                                                                                                                                                    
-            DECLARE_EXPORT_INFO;                                                                                                                                                    
-            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-            {                                                                                                                                                                       
-                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                    return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<JSFileSinkConstructor, WebCore::UseCustomHeapCellType::No>(                                                                    
-                    vm,                                                                                                                                                             
-                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },                                                                                 
-                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = std::forward<decltype(space)>(space); },                                                               
-                    [](auto& spaces) { return spaces.m_subspaceForJSSinkConstructor.get(); },                                                                                       
-                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkConstructor = std::forward<decltype(space)>(space); });                                                                    
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-            {                                                                                                                                                                       
-                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());                                                 
-            }                                                                                                                                                                       
-            void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);   
-            
-            
-            // Must be defined for each specialization class.
-            static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-                                                                                                                                                               
-        private:                                                                                                                                                                    
-            JSFileSinkConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
-                : Base(vm, structure, nativeFunction, nativeFunction)                                                                                                               
-                                                                                                                                                                                    
-            {                                                                                                                                                                       
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);                                                     
-        };                                                                                                                                                                          
-                                                                                                                                                                                    
-        class JSFileSink final : public JSC::JSDestructibleObject {                                                                                                              
-        public:                                                                                                                                                                     
-            using Base = JSC::JSDestructibleObject;                                                                                                                                 
-            static JSFileSink* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-            static constexpr SinkID Sink = SinkID::FileSink;                                          
-                                                                                                                                                                                    
-            DECLARE_EXPORT_INFO;                                                                                                                                                    
-            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-            {                                                                                                                                                                       
-                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                    return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<JSFileSink, WebCore::UseCustomHeapCellType::No>(                                                                                 
-                    vm,                                                                                                                                                             
-                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },                                                                                            
-                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = std::forward<decltype(space)>(space); },                                                                          
-                    [](auto& spaces) { return spaces.m_subspaceForJSSink.get(); },                                                                                                  
-                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSink = std::forward<decltype(space)>(space); });                                                                               
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            static void destroy(JSC::JSCell*);                                                                                                                                      
-            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-            {                                                                                                                                                                       
-                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
-            }                       
-            
-            static JSObject* createPrototype(VM& vm, JSDOMGlobalObject& globalObject);
-                                                                                                                                                                                    
-            ~JSFileSink();                                                                                                                                                       
-                                                                                                                                                                                    
-            void* wrapped() const { return m_sinkPtr; }    
-            DECLARE_VISIT_CHILDREN;                                                                                                                         
-
-            void detach() {
-                m_sinkPtr = nullptr;
-
-            }
-
-            static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-            void ref();
-            void unref();
-                                                                                                                                                                                    
-            void* m_sinkPtr;
-            int m_refCount { 1 };
-                                                                                                                                                                                    
-            JSFileSink(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
-                : Base(vm, structure)                                                                                                                                               
-            {                                                                                                                                                                       
-                m_sinkPtr = sinkPtr;
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            void finishCreation(JSC::VM&);
-        };
-
-     
-
-        class JSReadableFileSinkController final : public JSC::JSDestructibleObject {                                                                                                              
-            public:                                                                                                                                                                     
-                using Base = JSC::JSDestructibleObject;                                                                                                                                 
-                static JSReadableFileSinkController* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-                static constexpr SinkID Sink = SinkID::FileSink;                                          
-                                                                                                                                                                                        
-                DECLARE_EXPORT_INFO;                                                                                                                                                    
-                template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-                {                                                                                                                                                                       
-                    if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                        return nullptr;                                                                                                                                                 
-                    return WebCore::subspaceForImpl<JSReadableFileSinkController, WebCore::UseCustomHeapCellType::No>(                                                                                 
-                        vm,                                                                                                                                                             
-                        [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },                                                                                            
-                        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = std::forward<decltype(space)>(space); },                                                                          
-                        [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },                                                                                                  
-                        [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = std::forward<decltype(space)>(space); });                                                                               
-                }                                                                                                                                                                       
-                                                                                                                                                                                        
-                static void destroy(JSC::JSCell*);                                                                                                                                      
-                static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-                {                                                                                                                                                                       
-                    return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
-                }
-                static JSObject* createPrototype(VM& vm, JSDOMGlobalObject& globalObject);
-                                                                                                                                                                                        
-                ~JSReadableFileSinkController();                                                                                                                                                       
-
-
-                void* wrapped() const { return m_sinkPtr; }    
-                void detach();
-
-                void start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSValue onPull, JSC::JSValue onClose);
-                DECLARE_VISIT_CHILDREN;
-                                                                                                                                                                                        
-                static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-                void* m_sinkPtr;
-                mutable WriteBarrier<JSC::Unknown> m_onPull;
-                mutable WriteBarrier<JSC::Unknown> m_onClose;
-                mutable JSC::Weak<JSObject> m_weakReadableStream;
-                                                                                                                                                                                        
-                JSReadableFileSinkController(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
-                    : Base(vm, structure)                                                                                                                                               
-                {                                                                                                                                                                       
-                    m_sinkPtr = sinkPtr;
-                }                                                                                                                                                                       
-                                                                                                                                                                                        
-                void finishCreation(JSC::VM&);
-            };
-
-JSC_DECLARE_CUSTOM_GETTER(functionFileSink__getter);
-
-        
-class JSHTTPResponseSinkConstructor final : public JSC::InternalFunction {                                                                                                     
-        public:                                                                                                                                                                     
-            using Base = JSC::InternalFunction;                                                                                                                                     
-            static JSHTTPResponseSinkConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
-            static constexpr SinkID Sink = SinkID::HTTPResponseSink;
-                                                                                                                                                                                    
-            static constexpr unsigned StructureFlags = Base::StructureFlags;                                                                                                        
-            static constexpr bool needsDestruction = false;                                                                                                                         
-                                                                                                                                                                                    
-            DECLARE_EXPORT_INFO;                                                                                                                                                    
-            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-            {                                                                                                                                                                       
-                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                    return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<JSHTTPResponseSinkConstructor, WebCore::UseCustomHeapCellType::No>(                                                                    
-                    vm,                                                                                                                                                             
-                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },                                                                                 
-                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = std::forward<decltype(space)>(space); },                                                               
-                    [](auto& spaces) { return spaces.m_subspaceForJSSinkConstructor.get(); },                                                                                       
-                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkConstructor = std::forward<decltype(space)>(space); });                                                                    
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-            {                                                                                                                                                                       
-                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());                                                 
-            }                                                                                                                                                                       
-            void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);   
-            
-            
-            // Must be defined for each specialization class.
-            static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-                                                                                                                                                               
-        private:                                                                                                                                                                    
-            JSHTTPResponseSinkConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
-                : Base(vm, structure, nativeFunction, nativeFunction)                                                                                                               
-                                                                                                                                                                                    
-            {                                                                                                                                                                       
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);                                                     
-        };                                                                                                                                                                          
-                                                                                                                                                                                    
-        class JSHTTPResponseSink final : public JSC::JSDestructibleObject {                                                                                                              
-        public:                                                                                                                                                                     
-            using Base = JSC::JSDestructibleObject;                                                                                                                                 
-            static JSHTTPResponseSink* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-            static constexpr SinkID Sink = SinkID::HTTPResponseSink;                                          
-                                                                                                                                                                                    
-            DECLARE_EXPORT_INFO;                                                                                                                                                    
-            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-            {                                                                                                                                                                       
-                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                    return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<JSHTTPResponseSink, WebCore::UseCustomHeapCellType::No>(                                                                                 
-                    vm,                                                                                                                                                             
-                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },                                                                                            
-                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = std::forward<decltype(space)>(space); },                                                                          
-                    [](auto& spaces) { return spaces.m_subspaceForJSSink.get(); },                                                                                                  
-                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSink = std::forward<decltype(space)>(space); });                                                                               
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            static void destroy(JSC::JSCell*);                                                                                                                                      
-            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-            {                                                                                                                                                                       
-                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
-            }                       
-            
-            static JSObject* createPrototype(VM& vm, JSDOMGlobalObject& globalObject);
-                                                                                                                                                                                    
-            ~JSHTTPResponseSink();                                                                                                                                                       
-                                                                                                                                                                                    
-            void* wrapped() const { return m_sinkPtr; }    
-            DECLARE_VISIT_CHILDREN;                                                                                                                         
-
-            void detach() {
-                m_sinkPtr = nullptr;
-
-            }
-
-            static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-            void ref();
-            void unref();
-                                                                                                                                                                                    
-            void* m_sinkPtr;
-            int m_refCount { 1 };
-                                                                                                                                                                                    
-            JSHTTPResponseSink(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
-                : Base(vm, structure)                                                                                                                                               
-            {                                                                                                                                                                       
-                m_sinkPtr = sinkPtr;
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            void finishCreation(JSC::VM&);
-        };
-
-     
-
-        class JSReadableHTTPResponseSinkController final : public JSC::JSDestructibleObject {                                                                                                              
-            public:                                                                                                                                                                     
-                using Base = JSC::JSDestructibleObject;                                                                                                                                 
-                static JSReadableHTTPResponseSinkController* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-                static constexpr SinkID Sink = SinkID::HTTPResponseSink;                                          
-                                                                                                                                                                                        
-                DECLARE_EXPORT_INFO;                                                                                                                                                    
-                template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-                {                                                                                                                                                                       
-                    if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                        return nullptr;                                                                                                                                                 
-                    return WebCore::subspaceForImpl<JSReadableHTTPResponseSinkController, WebCore::UseCustomHeapCellType::No>(                                                                                 
-                        vm,                                                                                                                                                             
-                        [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },                                                                                            
-                        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = std::forward<decltype(space)>(space); },                                                                          
-                        [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },                                                                                                  
-                        [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = std::forward<decltype(space)>(space); });                                                                               
-                }                                                                                                                                                                       
-                                                                                                                                                                                        
-                static void destroy(JSC::JSCell*);                                                                                                                                      
-                static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-                {                                                                                                                                                                       
-                    return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
-                }
-                static JSObject* createPrototype(VM& vm, JSDOMGlobalObject& globalObject);
-                                                                                                                                                                                        
-                ~JSReadableHTTPResponseSinkController();                                                                                                                                                       
-
-
-                void* wrapped() const { return m_sinkPtr; }    
-                void detach();
-
-                void start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSValue onPull, JSC::JSValue onClose);
-                DECLARE_VISIT_CHILDREN;
-                                                                                                                                                                                        
-                static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-                void* m_sinkPtr;
-                mutable WriteBarrier<JSC::Unknown> m_onPull;
-                mutable WriteBarrier<JSC::Unknown> m_onClose;
-                mutable JSC::Weak<JSObject> m_weakReadableStream;
-                                                                                                                                                                                        
-                JSReadableHTTPResponseSinkController(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
-                    : Base(vm, structure)                                                                                                                                               
-                {                                                                                                                                                                       
-                    m_sinkPtr = sinkPtr;
-                }                                                                                                                                                                       
-                                                                                                                                                                                        
-                void finishCreation(JSC::VM&);
-            };
-
-JSC_DECLARE_CUSTOM_GETTER(functionHTTPResponseSink__getter);
-
-        
-class JSHTTPSResponseSinkConstructor final : public JSC::InternalFunction {                                                                                                     
-        public:                                                                                                                                                                     
-            using Base = JSC::InternalFunction;                                                                                                                                     
-            static JSHTTPSResponseSinkConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
-            static constexpr SinkID Sink = SinkID::HTTPSResponseSink;
-                                                                                                                                                                                    
-            static constexpr unsigned StructureFlags = Base::StructureFlags;                                                                                                        
-            static constexpr bool needsDestruction = false;                                                                                                                         
-                                                                                                                                                                                    
-            DECLARE_EXPORT_INFO;                                                                                                                                                    
-            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-            {                                                                                                                                                                       
-                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                    return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<JSHTTPSResponseSinkConstructor, WebCore::UseCustomHeapCellType::No>(                                                                    
-                    vm,                                                                                                                                                             
-                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },                                                                                 
-                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = std::forward<decltype(space)>(space); },                                                               
-                    [](auto& spaces) { return spaces.m_subspaceForJSSinkConstructor.get(); },                                                                                       
-                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkConstructor = std::forward<decltype(space)>(space); });                                                                    
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-            {                                                                                                                                                                       
-                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());                                                 
-            }                                                                                                                                                                       
-            void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);   
-            
-            
-            // Must be defined for each specialization class.
-            static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-                                                                                                                                                               
-        private:                                                                                                                                                                    
-            JSHTTPSResponseSinkConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
-                : Base(vm, structure, nativeFunction, nativeFunction)                                                                                                               
-                                                                                                                                                                                    
-            {                                                                                                                                                                       
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);                                                     
-        };                                                                                                                                                                          
-                                                                                                                                                                                    
-        class JSHTTPSResponseSink final : public JSC::JSDestructibleObject {                                                                                                              
-        public:                                                                                                                                                                     
-            using Base = JSC::JSDestructibleObject;                                                                                                                                 
-            static JSHTTPSResponseSink* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-            static constexpr SinkID Sink = SinkID::HTTPSResponseSink;                                          
-                                                                                                                                                                                    
-            DECLARE_EXPORT_INFO;                                                                                                                                                    
-            template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-            {                                                                                                                                                                       
-                if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                    return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<JSHTTPSResponseSink, WebCore::UseCustomHeapCellType::No>(                                                                                 
-                    vm,                                                                                                                                                             
-                    [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },                                                                                            
-                    [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = std::forward<decltype(space)>(space); },                                                                          
-                    [](auto& spaces) { return spaces.m_subspaceForJSSink.get(); },                                                                                                  
-                    [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSink = std::forward<decltype(space)>(space); });                                                                               
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            static void destroy(JSC::JSCell*);                                                                                                                                      
-            static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-            {                                                                                                                                                                       
-                return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
-            }                       
-            
-            static JSObject* createPrototype(VM& vm, JSDOMGlobalObject& globalObject);
-                                                                                                                                                                                    
-            ~JSHTTPSResponseSink();                                                                                                                                                       
-                                                                                                                                                                                    
-            void* wrapped() const { return m_sinkPtr; }    
-            DECLARE_VISIT_CHILDREN;                                                                                                                         
-
-            void detach() {
-                m_sinkPtr = nullptr;
-
-            }
-
-            static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-            void ref();
-            void unref();
-                                                                                                                                                                                    
-            void* m_sinkPtr;
-            int m_refCount { 1 };
-                                                                                                                                                                                    
-            JSHTTPSResponseSink(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
-                : Base(vm, structure)                                                                                                                                               
-            {                                                                                                                                                                       
-                m_sinkPtr = sinkPtr;
-            }                                                                                                                                                                       
-                                                                                                                                                                                    
-            void finishCreation(JSC::VM&);
-        };
-
-     
-
-        class JSReadableHTTPSResponseSinkController final : public JSC::JSDestructibleObject {                                                                                                              
-            public:                                                                                                                                                                     
-                using Base = JSC::JSDestructibleObject;                                                                                                                                 
-                static JSReadableHTTPSResponseSinkController* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-                static constexpr SinkID Sink = SinkID::HTTPSResponseSink;                                          
-                                                                                                                                                                                        
-                DECLARE_EXPORT_INFO;                                                                                                                                                    
-                template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
-                {                                                                                                                                                                       
-                    if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
-                        return nullptr;                                                                                                                                                 
-                    return WebCore::subspaceForImpl<JSReadableHTTPSResponseSinkController, WebCore::UseCustomHeapCellType::No>(                                                                                 
-                        vm,                                                                                                                                                             
-                        [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },                                                                                            
-                        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = std::forward<decltype(space)>(space); },                                                                          
-                        [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },                                                                                                  
-                        [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = std::forward<decltype(space)>(space); });                                                                               
-                }                                                                                                                                                                       
-                                                                                                                                                                                        
-                static void destroy(JSC::JSCell*);                                                                                                                                      
-                static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
-                {                                                                                                                                                                       
-                    return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
-                }
-                static JSObject* createPrototype(VM& vm, JSDOMGlobalObject& globalObject);
-                                                                                                                                                                                        
-                ~JSReadableHTTPSResponseSinkController();                                                                                                                                                       
-
-
-                void* wrapped() const { return m_sinkPtr; }    
-                void detach();
-
-                void start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSValue onPull, JSC::JSValue onClose);
-                DECLARE_VISIT_CHILDREN;
-                                                                                                                                                                                        
-                static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-
-                void* m_sinkPtr;
-                mutable WriteBarrier<JSC::Unknown> m_onPull;
-                mutable WriteBarrier<JSC::Unknown> m_onClose;
-                mutable JSC::Weak<JSObject> m_weakReadableStream;
-                                                                                                                                                                                        
-                JSReadableHTTPSResponseSinkController(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
-                    : Base(vm, structure)                                                                                                                                               
-                {                                                                                                                                                                       
-                    m_sinkPtr = sinkPtr;
-                }                                                                                                                                                                       
-                                                                                                                                                                                        
-                void finishCreation(JSC::VM&);
-            };
-
-JSC_DECLARE_CUSTOM_GETTER(functionHTTPSResponseSink__getter);
-
-        
-
-JSObject* createJSSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WebCore::SinkID sinkID);
-JSObject* createJSSinkControllerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WebCore::SinkID sinkID);
-Structure* createJSSinkControllerStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WebCore::SinkID sinkID);
-} // namespace WebCore
diff --git a/src/bun.js/bindings/JSSinkLookupTable.h b/src/bun.js/bindings/JSSinkLookupTable.h
deleted file mode 100644
index 78183692a..000000000
--- a/src/bun.js/bindings/JSSinkLookupTable.h
+++ /dev/null
@@ -1,321 +0,0 @@
-// Automatically generated from src/bun.js/bindings/JSSink.cpp using ./src/bun.js/scripts/create_hash_table. DO NOT EDIT!
-
-
-
-
-
-static const struct CompactHashIndex JSArrayBufferSinkPrototypeTableIndex[19] = {
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 6, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 0, 16 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 5, -1 },
-    { 4, -1 },
-    { 1, 17 },
-    { 2, 18 },
-    { 3, -1 },
-};
-
-static const struct HashTableValue JSArrayBufferSinkPrototypeTableValues[7] = {
-   { "close"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__doClose, 0 } },
-   { "flush"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__flush, 1 } },
-   { "end"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__end, 0 } },
-   { "start"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__start, 1 } },
-   { "write"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__write, 1 } },
-   { "ref"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__ref, 0 } },
-   { "unref"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__unref, 0 } },
-};
-
-static const struct HashTable JSArrayBufferSinkPrototypeTable =
-    { 7, 15, false, nullptr, JSArrayBufferSinkPrototypeTableValues, JSArrayBufferSinkPrototypeTableIndex };
-
-
-
-
-
-
-
-static const struct CompactHashIndex JSReadableArrayBufferSinkControllerPrototypeTableIndex[19] = {
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 0, 16 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 4, -1 },
-    { 1, 17 },
-    { 2, 18 },
-    { 3, -1 },
-};
-
-static const struct HashTableValue JSReadableArrayBufferSinkControllerPrototypeTableValues[5] = {
-   { "close"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, JSReadableArrayBufferSinkController__close, 0 } },
-   { "flush"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__flush, 1 } },
-   { "end"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, JSReadableArrayBufferSinkController__end, 0 } },
-   { "start"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__start, 1 } },
-   { "write"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ArrayBufferSink__write, 1 } },
-};
-
-static const struct HashTable JSReadableArrayBufferSinkControllerPrototypeTable =
-    { 5, 15, false, nullptr, JSReadableArrayBufferSinkControllerPrototypeTableValues, JSReadableArrayBufferSinkControllerPrototypeTableIndex };
-
-
-
-
-
-
-
-static const struct CompactHashIndex JSFileSinkPrototypeTableIndex[19] = {
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 6, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 0, 16 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 5, -1 },
-    { 4, -1 },
-    { 1, 17 },
-    { 2, 18 },
-    { 3, -1 },
-};
-
-static const struct HashTableValue JSFileSinkPrototypeTableValues[7] = {
-   { "close"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__doClose, 0 } },
-   { "flush"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__flush, 1 } },
-   { "end"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__end, 0 } },
-   { "start"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__start, 1 } },
-   { "write"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__write, 1 } },
-   { "ref"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__ref, 0 } },
-   { "unref"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__unref, 0 } },
-};
-
-static const struct HashTable JSFileSinkPrototypeTable =
-    { 7, 15, false, nullptr, JSFileSinkPrototypeTableValues, JSFileSinkPrototypeTableIndex };
-
-
-
-
-
-
-
-static const struct CompactHashIndex JSReadableFileSinkControllerPrototypeTableIndex[19] = {
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 0, 16 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 4, -1 },
-    { 1, 17 },
-    { 2, 18 },
-    { 3, -1 },
-};
-
-static const struct HashTableValue JSReadableFileSinkControllerPrototypeTableValues[5] = {
-   { "close"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, JSReadableFileSinkController__close, 0 } },
-   { "flush"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__flush, 1 } },
-   { "end"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, JSReadableFileSinkController__end, 0 } },
-   { "start"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__start, 1 } },
-   { "write"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSink__write, 1 } },
-};
-
-static const struct HashTable JSReadableFileSinkControllerPrototypeTable =
-    { 5, 15, false, nullptr, JSReadableFileSinkControllerPrototypeTableValues, JSReadableFileSinkControllerPrototypeTableIndex };
-
-
-
-
-
-
-
-static const struct CompactHashIndex JSHTTPResponseSinkPrototypeTableIndex[19] = {
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 6, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 0, 16 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 5, -1 },
-    { 4, -1 },
-    { 1, 17 },
-    { 2, 18 },
-    { 3, -1 },
-};
-
-static const struct HashTableValue JSHTTPResponseSinkPrototypeTableValues[7] = {
-   { "close"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__doClose, 0 } },
-   { "flush"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__flush, 1 } },
-   { "end"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__end, 0 } },
-   { "start"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__start, 1 } },
-   { "write"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__write, 1 } },
-   { "ref"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__ref, 0 } },
-   { "unref"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__unref, 0 } },
-};
-
-static const struct HashTable JSHTTPResponseSinkPrototypeTable =
-    { 7, 15, false, nullptr, JSHTTPResponseSinkPrototypeTableValues, JSHTTPResponseSinkPrototypeTableIndex };
-
-
-
-
-
-
-
-static const struct CompactHashIndex JSReadableHTTPResponseSinkControllerPrototypeTableIndex[19] = {
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 0, 16 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 4, -1 },
-    { 1, 17 },
-    { 2, 18 },
-    { 3, -1 },
-};
-
-static const struct HashTableValue JSReadableHTTPResponseSinkControllerPrototypeTableValues[5] = {
-   { "close"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, JSReadableHTTPResponseSinkController__close, 0 } },
-   { "flush"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__flush, 1 } },
-   { "end"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, JSReadableHTTPResponseSinkController__end, 0 } },
-   { "start"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__start, 1 } },
-   { "write"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPResponseSink__write, 1 } },
-};
-
-static const struct HashTable JSReadableHTTPResponseSinkControllerPrototypeTable =
-    { 5, 15, false, nullptr, JSReadableHTTPResponseSinkControllerPrototypeTableValues, JSReadableHTTPResponseSinkControllerPrototypeTableIndex };
-
-
-
-
-
-
-
-static const struct CompactHashIndex JSHTTPSResponseSinkPrototypeTableIndex[19] = {
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 6, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 0, 16 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 5, -1 },
-    { 4, -1 },
-    { 1, 17 },
-    { 2, 18 },
-    { 3, -1 },
-};
-
-static const struct HashTableValue JSHTTPSResponseSinkPrototypeTableValues[7] = {
-   { "close"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__doClose, 0 } },
-   { "flush"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__flush, 1 } },
-   { "end"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__end, 0 } },
-   { "start"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__start, 1 } },
-   { "write"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__write, 1 } },
-   { "ref"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__ref, 0 } },
-   { "unref"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__unref, 0 } },
-};
-
-static const struct HashTable JSHTTPSResponseSinkPrototypeTable =
-    { 7, 15, false, nullptr, JSHTTPSResponseSinkPrototypeTableValues, JSHTTPSResponseSinkPrototypeTableIndex };
-
-
-
-
-
-
-
-static const struct CompactHashIndex JSReadableHTTPSResponseSinkControllerPrototypeTableIndex[19] = {
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 0, 16 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { -1, -1 },
-    { 4, -1 },
-    { 1, 17 },
-    { 2, 18 },
-    { 3, -1 },
-};
-
-static const struct HashTableValue JSReadableHTTPSResponseSinkControllerPrototypeTableValues[5] = {
-   { "close"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, JSReadableHTTPSResponseSinkController__close, 0 } },
-   { "flush"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__flush, 1 } },
-   { "end"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, JSReadableHTTPSResponseSinkController__end, 0 } },
-   { "start"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__start, 1 } },
-   { "write"_s, static_cast<unsigned>(PropertyAttribute::ReadOnly|PropertyAttribute::DontDelete|PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSResponseSink__write, 1 } },
-};
-
-static const struct HashTable JSReadableHTTPSResponseSinkControllerPrototypeTable =
-    { 5, 15, false, nullptr, JSReadableHTTPSResponseSinkControllerPrototypeTableValues, JSReadableHTTPSResponseSinkControllerPrototypeTableIndex };
-
-
diff --git a/src/bun.js/bindings/ZigGeneratedClasses.cpp b/src/bun.js/bindings/ZigGeneratedClasses.cpp
index f709d572a..b3b768ecc 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses.cpp
+++ b/src/bun.js/bindings/ZigGeneratedClasses.cpp
@@ -23,62 +23,78 @@
 #include "JSDOMConvertBufferSource.h"
 #include "ZigGeneratedClasses.h"
 
+
+
+
 namespace WebCore {
 
 using namespace JSC;
 using namespace Zig;
 
-class JSAttributeIteratorPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
 
-    static JSAttributeIteratorPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSAttributeIteratorPrototype* ptr = new (NotNull, JSC::allocateCell<JSAttributeIteratorPrototype>(vm)) JSAttributeIteratorPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+  class JSAttributeIteratorPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSAttributeIteratorPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSAttributeIteratorPrototype* ptr = new (NotNull, JSC::allocateCell<JSAttributeIteratorPrototype>(vm)) JSAttributeIteratorPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSAttributeIteratorPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSAttributeIteratorPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
+
+extern "C" void* AttributeIteratorClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsAttributeIteratorConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSAttributeIteratorPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSAttributeIteratorPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* AttributeIteratorClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsAttributeIteratorConstructor);
 
 extern "C" void AttributeIteratorClass__finalize(void*);
 
+
 extern "C" EncodedJSValue AttributeIteratorPrototype__getThis(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(AttributeIteratorPrototype__iteratorCallback);
 
+
 extern "C" EncodedJSValue AttributeIteratorPrototype__next(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(AttributeIteratorPrototype__nextCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSAttributeIteratorPrototype, JSAttributeIteratorPrototype::Base);
 
-static const HashTableValue JSAttributeIteratorPrototypeTableValues[] = {
-    { "next"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, AttributeIteratorPrototype__nextCallback, 0 } }
+
+  static const HashTableValue JSAttributeIteratorPrototypeTableValues[] = {
+{ "next"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, AttributeIteratorPrototype__nextCallback, 0 } }
 };
 
+
+
 const ClassInfo JSAttributeIteratorPrototype::s_info = { "AttributeIterator"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSAttributeIteratorPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsAttributeIteratorConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -89,63 +105,67 @@ JSC_DEFINE_CUSTOM_GETTER(jsAttributeIteratorConstructor, (JSGlobalObject * lexic
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for AttributeIterator"_s);
     return JSValue::encode(globalObject->JSAttributeIteratorConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(AttributeIteratorPrototype__iteratorCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSAttributeIterator* thisObject = jsDynamicCast<JSAttributeIterator*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(AttributeIteratorPrototype__iteratorCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof AttributeIterator"_s);
-        return JSValue::encode({});
-    }
+        JSAttributeIterator* thisObject = jsDynamicCast<JSAttributeIterator*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof AttributeIterator"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return AttributeIteratorPrototype__getThis(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return AttributeIteratorPrototype__getThis(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(AttributeIteratorPrototype__nextCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(AttributeIteratorPrototype__nextCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSAttributeIterator* thisObject = jsDynamicCast<JSAttributeIterator*>(callFrame->thisValue());
 
-    JSAttributeIterator* thisObject = jsDynamicCast<JSAttributeIterator*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof AttributeIterator"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof AttributeIterator"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return AttributeIteratorPrototype__next(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return AttributeIteratorPrototype__next(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSAttributeIteratorPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -165,7 +185,7 @@ void JSAttributeIterator::destroy(JSCell* cell)
 {
     static_cast<JSAttributeIterator*>(cell)->JSAttributeIterator::~JSAttributeIterator();
 }
-
+  
 const ClassInfo JSAttributeIterator::s_info = { "AttributeIterator"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSAttributeIterator) };
 
 void JSAttributeIterator::finishCreation(VM& vm)
@@ -174,38 +194,37 @@ void JSAttributeIterator::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSAttributeIterator* JSAttributeIterator::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSAttributeIterator* ptr = new (NotNull, JSC::allocateCell<JSAttributeIterator>(vm)) JSAttributeIterator(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* AttributeIterator__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSAttributeIterator* JSAttributeIterator::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSAttributeIterator* ptr = new (NotNull, JSC::allocateCell<JSAttributeIterator>(vm)) JSAttributeIterator(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSAttributeIterator* object = JSC::jsDynamicCast<JSAttributeIterator*>(cell);
+extern "C" void* AttributeIterator__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSAttributeIterator* object = JSC::jsDynamicCast<JSAttributeIterator*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool AttributeIterator__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSAttributeIterator* object = JSC::jsDynamicCast<JSAttributeIterator*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool AttributeIterator__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSAttributeIterator* object = JSC::jsDynamicCast<JSAttributeIterator*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t AttributeIterator__ptrOffset = JSAttributeIterator::offsetOfWrapped();
 
 void JSAttributeIterator::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -218,145 +237,167 @@ void JSAttributeIterator::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSAttributeIterator::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSAttributeIteratorPrototype::create(vm, globalObject, JSAttributeIteratorPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue AttributeIterator__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSAttributeIteratorStructure();
-    JSAttributeIterator* instance = JSAttributeIterator::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSBigIntStatsPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSBigIntStatsPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSBigIntStatsPrototype* ptr = new (NotNull, JSC::allocateCell<JSBigIntStatsPrototype>(vm)) JSBigIntStatsPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBigIntStatsPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSBigIntStatsPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue AttributeIterator__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSAttributeIteratorStructure();
+  JSAttributeIterator* instance = JSAttributeIterator::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSBigIntStatsPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSBigIntStatsPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSBigIntStatsPrototype* ptr = new (NotNull, JSC::allocateCell<JSBigIntStatsPrototype>(vm)) JSBigIntStatsPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBigIntStatsPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSBigIntStatsPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSBigIntStatsConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSBigIntStatsConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBigIntStatsPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSBigIntStatsConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBigIntStatsPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSBigIntStatsConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForBigIntStatsConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBigIntStatsConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForBigIntStatsConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForBigIntStatsConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSBigIntStatsPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSBigIntStatsConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSBigIntStatsPrototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSBigIntStatsConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForBigIntStatsConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBigIntStatsConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForBigIntStatsConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForBigIntStatsConstructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSBigIntStatsPrototype* prototype);
+extern "C" void* BigIntStatsClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsBigIntStatsConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSBigIntStatsConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSBigIntStatsPrototype* prototype);
-};
 
-extern "C" void* BigIntStatsClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsBigIntStatsConstructor);
 
 extern "C" void BigIntStatsClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__atime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__atimeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__atimeMs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__atimeMsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__atimeNs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__atimeNsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__birthtime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__birthtimeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__birthtimeMs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__birthtimeMsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__birthtimeNs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__birthtimeNsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__blksize(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__blksizeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__blocks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__blocksGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__ctime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__ctimeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__ctimeMs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__ctimeMsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__ctimeNs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__ctimeNsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__dev(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__devGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__gid(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__gidGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__ino(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__inoGetterWrap);
 
+
 extern "C" EncodedJSValue BigIntStatsPrototype__isBlockDevice_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BigIntStatsPrototype__isBlockDeviceCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(BigIntStatsPrototype__isBlockDeviceWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue BigIntStatsPrototype__isBlockDevice_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue BigIntStatsPrototype__isBlockDevice_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isBlockDevice(BigIntStatsPrototype__isBlockDeviceWithoutTypeChecksWrapper,
-    JSBigIntStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isBlockDevice(BigIntStatsPrototype__isBlockDeviceWithoutTypeChecksWrapper, 
+  JSBigIntStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isBlockDeviceWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -371,13 +412,14 @@ JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isBlockDeviceWithoutTypeChecksWra
 extern "C" EncodedJSValue BigIntStatsPrototype__isCharacterDevice_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BigIntStatsPrototype__isCharacterDeviceCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(BigIntStatsPrototype__isCharacterDeviceWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue BigIntStatsPrototype__isCharacterDevice_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue BigIntStatsPrototype__isCharacterDevice_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isCharacterDevice(BigIntStatsPrototype__isCharacterDeviceWithoutTypeChecksWrapper,
-    JSBigIntStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isCharacterDevice(BigIntStatsPrototype__isCharacterDeviceWithoutTypeChecksWrapper, 
+  JSBigIntStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isCharacterDeviceWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -392,13 +434,14 @@ JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isCharacterDeviceWithoutTypeCheck
 extern "C" EncodedJSValue BigIntStatsPrototype__isDirectory_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BigIntStatsPrototype__isDirectoryCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(BigIntStatsPrototype__isDirectoryWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue BigIntStatsPrototype__isDirectory_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue BigIntStatsPrototype__isDirectory_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isDirectory(BigIntStatsPrototype__isDirectoryWithoutTypeChecksWrapper,
-    JSBigIntStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isDirectory(BigIntStatsPrototype__isDirectoryWithoutTypeChecksWrapper, 
+  JSBigIntStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isDirectoryWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -413,13 +456,14 @@ JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isDirectoryWithoutTypeChecksWrapp
 extern "C" EncodedJSValue BigIntStatsPrototype__isFIFO_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BigIntStatsPrototype__isFIFOCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(BigIntStatsPrototype__isFIFOWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue BigIntStatsPrototype__isFIFO_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue BigIntStatsPrototype__isFIFO_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isFIFO(BigIntStatsPrototype__isFIFOWithoutTypeChecksWrapper,
-    JSBigIntStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isFIFO(BigIntStatsPrototype__isFIFOWithoutTypeChecksWrapper, 
+  JSBigIntStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isFIFOWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -434,13 +478,14 @@ JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isFIFOWithoutTypeChecksWrapper, E
 extern "C" EncodedJSValue BigIntStatsPrototype__isFile_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BigIntStatsPrototype__isFileCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(BigIntStatsPrototype__isFileWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue BigIntStatsPrototype__isFile_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue BigIntStatsPrototype__isFile_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isFile(BigIntStatsPrototype__isFileWithoutTypeChecksWrapper,
-    JSBigIntStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isFile(BigIntStatsPrototype__isFileWithoutTypeChecksWrapper, 
+  JSBigIntStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isFileWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -455,13 +500,14 @@ JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isFileWithoutTypeChecksWrapper, E
 extern "C" EncodedJSValue BigIntStatsPrototype__isSocket_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BigIntStatsPrototype__isSocketCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(BigIntStatsPrototype__isSocketWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue BigIntStatsPrototype__isSocket_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue BigIntStatsPrototype__isSocket_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isSocket(BigIntStatsPrototype__isSocketWithoutTypeChecksWrapper,
-    JSBigIntStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isSocket(BigIntStatsPrototype__isSocketWithoutTypeChecksWrapper, 
+  JSBigIntStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isSocketWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -476,13 +522,14 @@ JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isSocketWithoutTypeChecksWrapper,
 extern "C" EncodedJSValue BigIntStatsPrototype__isSymbolicLink_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BigIntStatsPrototype__isSymbolicLinkCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(BigIntStatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue BigIntStatsPrototype__isSymbolicLink_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue BigIntStatsPrototype__isSymbolicLink_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isSymbolicLink(BigIntStatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper,
-    JSBigIntStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForBigIntStatsPrototype__isSymbolicLink(BigIntStatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper, 
+  JSBigIntStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -497,63 +544,76 @@ JSC_DEFINE_JIT_OPERATION(BigIntStatsPrototype__isSymbolicLinkWithoutTypeChecksWr
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__mode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__modeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__mtime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__mtimeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__mtimeMs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__mtimeMsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__mtimeNs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__mtimeNsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__nlink(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__nlinkGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__rdev(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__rdevGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__size(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__sizeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BigIntStatsPrototype__uid(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BigIntStatsPrototype__uidGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBigIntStatsPrototype, JSBigIntStatsPrototype::Base);
 
-static const HashTableValue JSBigIntStatsPrototypeTableValues[] = {
-    { "atime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__atimeGetterWrap, 0 } },
-    { "atimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__atimeMsGetterWrap, 0 } },
-    { "atimeNs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__atimeNsGetterWrap, 0 } },
-    { "birthtime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__birthtimeGetterWrap, 0 } },
-    { "birthtimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__birthtimeMsGetterWrap, 0 } },
-    { "birthtimeNs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__birthtimeNsGetterWrap, 0 } },
-    { "blksize"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__blksizeGetterWrap, 0 } },
-    { "blocks"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__blocksGetterWrap, 0 } },
-    { "ctime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__ctimeGetterWrap, 0 } },
-    { "ctimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__ctimeMsGetterWrap, 0 } },
-    { "ctimeNs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__ctimeNsGetterWrap, 0 } },
-    { "dev"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__devGetterWrap, 0 } },
-    { "gid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__gidGetterWrap, 0 } },
-    { "ino"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__inoGetterWrap, 0 } },
-    { "isBlockDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isBlockDeviceCallback, &DOMJITSignatureForBigIntStatsPrototype__isBlockDevice } },
-    { "isCharacterDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isCharacterDeviceCallback, &DOMJITSignatureForBigIntStatsPrototype__isCharacterDevice } },
-    { "isDirectory"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isDirectoryCallback, &DOMJITSignatureForBigIntStatsPrototype__isDirectory } },
-    { "isFIFO"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isFIFOCallback, &DOMJITSignatureForBigIntStatsPrototype__isFIFO } },
-    { "isFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isFileCallback, &DOMJITSignatureForBigIntStatsPrototype__isFile } },
-    { "isSocket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isSocketCallback, &DOMJITSignatureForBigIntStatsPrototype__isSocket } },
-    { "isSymbolicLink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isSymbolicLinkCallback, &DOMJITSignatureForBigIntStatsPrototype__isSymbolicLink } },
-    { "mode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__modeGetterWrap, 0 } },
-    { "mtime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__mtimeGetterWrap, 0 } },
-    { "mtimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__mtimeMsGetterWrap, 0 } },
-    { "mtimeNs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__mtimeNsGetterWrap, 0 } },
-    { "nlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__nlinkGetterWrap, 0 } },
-    { "rdev"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__rdevGetterWrap, 0 } },
-    { "size"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__sizeGetterWrap, 0 } },
-    { "uid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__uidGetterWrap, 0 } }
+
+  static const HashTableValue JSBigIntStatsPrototypeTableValues[] = {
+{ "atime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__atimeGetterWrap, 0 } }  ,
+{ "atimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__atimeMsGetterWrap, 0 } }  ,
+{ "atimeNs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__atimeNsGetterWrap, 0 } }  ,
+{ "birthtime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__birthtimeGetterWrap, 0 } }  ,
+{ "birthtimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__birthtimeMsGetterWrap, 0 } }  ,
+{ "birthtimeNs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__birthtimeNsGetterWrap, 0 } }  ,
+{ "blksize"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__blksizeGetterWrap, 0 } }  ,
+{ "blocks"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__blocksGetterWrap, 0 } }  ,
+{ "ctime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__ctimeGetterWrap, 0 } }  ,
+{ "ctimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__ctimeMsGetterWrap, 0 } }  ,
+{ "ctimeNs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__ctimeNsGetterWrap, 0 } }  ,
+{ "dev"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__devGetterWrap, 0 } }  ,
+{ "gid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__gidGetterWrap, 0 } }  ,
+{ "ino"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__inoGetterWrap, 0 } }  ,
+{ "isBlockDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isBlockDeviceCallback, &DOMJITSignatureForBigIntStatsPrototype__isBlockDevice } }  ,
+{ "isCharacterDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isCharacterDeviceCallback, &DOMJITSignatureForBigIntStatsPrototype__isCharacterDevice } }  ,
+{ "isDirectory"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isDirectoryCallback, &DOMJITSignatureForBigIntStatsPrototype__isDirectory } }  ,
+{ "isFIFO"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isFIFOCallback, &DOMJITSignatureForBigIntStatsPrototype__isFIFO } }  ,
+{ "isFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isFileCallback, &DOMJITSignatureForBigIntStatsPrototype__isFile } }  ,
+{ "isSocket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isSocketCallback, &DOMJITSignatureForBigIntStatsPrototype__isSocket } }  ,
+{ "isSymbolicLink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, BigIntStatsPrototype__isSymbolicLinkCallback, &DOMJITSignatureForBigIntStatsPrototype__isSymbolicLink } }  ,
+{ "mode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__modeGetterWrap, 0 } }  ,
+{ "mtime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__mtimeGetterWrap, 0 } }  ,
+{ "mtimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__mtimeMsGetterWrap, 0 } }  ,
+{ "mtimeNs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__mtimeNsGetterWrap, 0 } }  ,
+{ "nlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__nlinkGetterWrap, 0 } }  ,
+{ "rdev"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__rdevGetterWrap, 0 } }  ,
+{ "size"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__sizeGetterWrap, 0 } }  ,
+{ "uid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BigIntStatsPrototype__uidGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSBigIntStatsPrototype::s_info = { "BigIntStats"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBigIntStatsPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsBigIntStatsConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -564,43 +624,49 @@ JSC_DEFINE_CUSTOM_GETTER(jsBigIntStatsConstructor, (JSGlobalObject * lexicalGlob
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for BigIntStats"_s);
     return JSValue::encode(globalObject->JSBigIntStatsConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__atimeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_atime.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BigIntStatsPrototype__atime(thisObject->wrapped(), globalObject));
+        BigIntStatsPrototype__atime(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_atime.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BigIntStatsPrototype__atimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
-    thisObject->m_atime.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BigIntStatsPrototype__atimeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BigIntStatsPrototype__atimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
+      thisObject->m_atime.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BigIntStatsPrototype__atimeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_atime.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__atimeMsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -608,11 +674,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__atimeMsGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__atimeNsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -620,42 +687,47 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__atimeNsGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__birthtimeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_birthtime.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BigIntStatsPrototype__birthtime(thisObject->wrapped(), globalObject));
+        BigIntStatsPrototype__birthtime(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_birthtime.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BigIntStatsPrototype__birthtimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
-    thisObject->m_birthtime.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BigIntStatsPrototype__birthtimeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BigIntStatsPrototype__birthtimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
+      thisObject->m_birthtime.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BigIntStatsPrototype__birthtimeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_birthtime.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__birthtimeMsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -663,11 +735,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__birthtimeMsGetterWrap, (JSGlobalO
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__birthtimeNsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -675,11 +748,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__birthtimeNsGetterWrap, (JSGlobalO
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__blksizeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -687,11 +761,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__blksizeGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__blocksGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -699,42 +774,47 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__blocksGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__ctimeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_ctime.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BigIntStatsPrototype__ctime(thisObject->wrapped(), globalObject));
+        BigIntStatsPrototype__ctime(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_ctime.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BigIntStatsPrototype__ctimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
-    thisObject->m_ctime.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BigIntStatsPrototype__ctimeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BigIntStatsPrototype__ctimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
+      thisObject->m_ctime.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BigIntStatsPrototype__ctimeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_ctime.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__ctimeMsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -742,11 +822,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__ctimeMsGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__ctimeNsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -754,11 +835,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__ctimeNsGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__devGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -766,11 +848,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__devGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__gidGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -778,11 +861,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__gidGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__inoGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -790,207 +874,215 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__inoGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isBlockDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isBlockDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
+        JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BigIntStatsPrototype__isBlockDevice_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BigIntStatsPrototype__isBlockDevice_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isCharacterDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isCharacterDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
 
-    JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BigIntStatsPrototype__isCharacterDevice_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BigIntStatsPrototype__isCharacterDevice_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isDirectoryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isDirectoryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
 
-    JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BigIntStatsPrototype__isDirectory_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BigIntStatsPrototype__isDirectory_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isFIFOCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isFIFOCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
 
-    JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BigIntStatsPrototype__isFIFO_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BigIntStatsPrototype__isFIFO_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
 
-    JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BigIntStatsPrototype__isFile_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BigIntStatsPrototype__isFile_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isSocketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isSocketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
 
-    JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BigIntStatsPrototype__isSocket_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BigIntStatsPrototype__isSocket_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isSymbolicLinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BigIntStatsPrototype__isSymbolicLinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
 
-    JSBigIntStats* thisObject = jsDynamicCast<JSBigIntStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BigIntStats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BigIntStatsPrototype__isSymbolicLink_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return BigIntStatsPrototype__isSymbolicLink_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__modeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -998,42 +1090,47 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__modeGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__mtimeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_mtime.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BigIntStatsPrototype__mtime(thisObject->wrapped(), globalObject));
+        BigIntStatsPrototype__mtime(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_mtime.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BigIntStatsPrototype__mtimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
-    thisObject->m_mtime.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BigIntStatsPrototype__mtimeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BigIntStatsPrototype__mtimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
+      thisObject->m_mtime.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BigIntStatsPrototype__mtimeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_mtime.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__mtimeMsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1041,11 +1138,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__mtimeMsGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__mtimeNsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1053,11 +1151,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__mtimeNsGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__nlinkGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1065,11 +1164,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__nlinkGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__rdevGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1077,11 +1177,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__rdevGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__sizeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1089,11 +1190,12 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__sizeGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__uidGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1101,6 +1203,7 @@ JSC_DEFINE_CUSTOM_GETTER(BigIntStatsPrototype__uidGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 void JSBigIntStatsPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -1112,64 +1215,67 @@ void JSBigIntStatsPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* gl
 void JSBigIntStatsConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSBigIntStatsPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "BigIntStats"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSBigIntStatsConstructor::JSBigIntStatsConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSBigIntStatsConstructor::JSBigIntStatsConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSBigIntStatsConstructor* JSBigIntStatsConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBigIntStatsPrototype* prototype)
-{
+  }
+
+JSBigIntStatsConstructor* JSBigIntStatsConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBigIntStatsPrototype* prototype) {
     JSBigIntStatsConstructor* ptr = new (NotNull, JSC::allocateCell<JSBigIntStatsConstructor>(vm)) JSBigIntStatsConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSBigIntStatsConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSBigIntStatsConstructor();
     Structure* structure = globalObject->JSBigIntStatsStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSBigIntStatsStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSBigIntStatsStructure()
+      );
     }
 
     void* ptr = BigIntStatsClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSBigIntStats* instance = JSBigIntStats::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSBigIntStatsConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSBigIntStatsPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSBigIntStatsConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBigIntStatsConstructor) };
 
-extern "C" EncodedJSValue BigIntStats__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue BigIntStats__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSBigIntStatsConstructor());
-}
+  }
 
 JSBigIntStats::~JSBigIntStats()
 {
@@ -1181,7 +1287,7 @@ void JSBigIntStats::destroy(JSCell* cell)
 {
     static_cast<JSBigIntStats*>(cell)->JSBigIntStats::~JSBigIntStats();
 }
-
+  
 const ClassInfo JSBigIntStats::s_info = { "BigIntStats"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBigIntStats) };
 
 void JSBigIntStats::finishCreation(VM& vm)
@@ -1190,38 +1296,37 @@ void JSBigIntStats::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSBigIntStats* JSBigIntStats::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSBigIntStats* ptr = new (NotNull, JSC::allocateCell<JSBigIntStats>(vm)) JSBigIntStats(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* BigIntStats__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSBigIntStats* JSBigIntStats::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSBigIntStats* ptr = new (NotNull, JSC::allocateCell<JSBigIntStats>(vm)) JSBigIntStats(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSBigIntStats* object = JSC::jsDynamicCast<JSBigIntStats*>(cell);
+extern "C" void* BigIntStats__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSBigIntStats* object = JSC::jsDynamicCast<JSBigIntStats*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool BigIntStats__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSBigIntStats* object = JSC::jsDynamicCast<JSBigIntStats*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool BigIntStats__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSBigIntStats* object = JSC::jsDynamicCast<JSBigIntStats*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t BigIntStats__ptrOffset = JSBigIntStats::offsetOfWrapped();
 
 void JSBigIntStats::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -1236,7 +1341,7 @@ void JSBigIntStats::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSBigIntStats::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSBigIntStatsConstructor::create(vm, globalObject, WebCore::JSBigIntStatsConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSBigIntStatsPrototype*>(prototype));
+  return WebCore::JSBigIntStatsConstructor::create(vm, globalObject, WebCore::JSBigIntStatsConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSBigIntStatsPrototype*>(prototype));
 }
 
 JSObject* JSBigIntStats::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -1244,13 +1349,12 @@ JSObject* JSBigIntStats::createPrototype(VM& vm, JSDOMGlobalObject* globalObject
     return JSBigIntStatsPrototype::create(vm, globalObject, JSBigIntStatsPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue BigIntStats__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSBigIntStatsStructure();
-    JSBigIntStats* instance = JSBigIntStats::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue BigIntStats__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSBigIntStatsStructure();
+  JSBigIntStats* instance = JSBigIntStats::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -1259,7 +1363,7 @@ void JSBigIntStats::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -1268,19 +1372,20 @@ DEFINE_VISIT_CHILDREN(JSBigIntStats);
 template<typename Visitor>
 void JSBigIntStats::visitAdditionalChildren(Visitor& visitor)
 {
-    JSBigIntStats* thisObject = this;
+  JSBigIntStats* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_atime);
+    
+        visitor.append(thisObject->m_atime);
     visitor.append(thisObject->m_birthtime);
     visitor.append(thisObject->m_ctime);
     visitor.append(thisObject->m_mtime);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSBigIntStats);
 
 template<typename Visitor>
-void JSBigIntStats::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSBigIntStats::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSBigIntStats* thisObject = jsCast<JSBigIntStats*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -1288,139 +1393,158 @@ void JSBigIntStats::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSBigIntStats);
-class JSBlobPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSBlobPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSBlobPrototype* ptr = new (NotNull, JSC::allocateCell<JSBlobPrototype>(vm)) JSBlobPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBlobPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSBlobPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSBlobPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSBlobPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSBlobPrototype* ptr = new (NotNull, JSC::allocateCell<JSBlobPrototype>(vm)) JSBlobPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBlobPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSBlobPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSBlobConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSBlobConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBlobPrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSBlobConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForBlobConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBlobConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForBlobConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForBlobConstructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSBlobPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSBlobConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBlobPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSBlobConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForBlobConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBlobConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForBlobConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForBlobConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSBlobPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSBlobConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSBlobPrototype* prototype);
+    };
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-
-    DECLARE_EXPORT_INFO;
-
-private:
-    JSBlobConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSBlobPrototype* prototype);
-};
 
 extern "C" void* BlobClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsBlobConstructor);
 
-extern "C" void Blob__onStructuredCloneSerialize(void*, JSC::JSGlobalObject*, void*, void (*)(CloneSerializer*, const uint8_t*, uint32_t));
+extern "C" void Blob__onStructuredCloneSerialize(void*, JSC::JSGlobalObject*, void*, void (*) (CloneSerializer*, const uint8_t*, uint32_t));
 
 extern "C" JSC::EncodedJSValue Blob__onStructuredCloneDeserialize(JSC::JSGlobalObject*, const uint8_t*, const uint8_t*);
 
 extern "C" void BlobClass__finalize(void*);
 
+
 extern "C" EncodedJSValue BlobPrototype__getArrayBuffer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BlobPrototype__arrayBufferCallback);
 
+
 extern "C" EncodedJSValue BlobPrototype__getExists(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BlobPrototype__existsCallback);
 
+
 extern "C" EncodedJSValue BlobPrototype__getFormData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BlobPrototype__formDataCallback);
 
+
 extern "C" EncodedJSValue BlobPrototype__getJSON(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BlobPrototype__jsonCallback);
 
+
 extern "C" JSC::EncodedJSValue BlobPrototype__getLastModified(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BlobPrototype__lastModifiedGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BlobPrototype__getName(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BlobPrototype__nameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BlobPrototype__getSize(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BlobPrototype__sizeGetterWrap);
 
+
 extern "C" EncodedJSValue BlobPrototype__getSlice(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BlobPrototype__sliceCallback);
 
+
 extern "C" EncodedJSValue BlobPrototype__getStream(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BlobPrototype__streamCallback);
 
+
 extern "C" EncodedJSValue BlobPrototype__getText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BlobPrototype__textCallback);
 
+
 extern "C" JSC::EncodedJSValue BlobPrototype__getType(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BlobPrototype__typeGetterWrap);
 
+
 extern "C" EncodedJSValue BlobPrototype__getWriter(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BlobPrototype__writerCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBlobPrototype, JSBlobPrototype::Base);
 
-static const HashTableValue JSBlobPrototypeTableValues[] = {
-    { "arrayBuffer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__arrayBufferCallback, 0 } },
-    { "exists"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__existsCallback, 0 } },
-    { "formData"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__formDataCallback, 0 } },
-    { "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__jsonCallback, 0 } },
-    { "lastModified"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BlobPrototype__lastModifiedGetterWrap, 0 } },
-    { "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BlobPrototype__nameGetterWrap, 0 } },
-    { "size"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BlobPrototype__sizeGetterWrap, 0 } },
-    { "slice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__sliceCallback, 2 } },
-    { "stream"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__streamCallback, 1 } },
-    { "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__textCallback, 0 } },
-    { "type"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BlobPrototype__typeGetterWrap, 0 } },
-    { "writer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__writerCallback, 1 } }
+
+  static const HashTableValue JSBlobPrototypeTableValues[] = {
+{ "arrayBuffer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__arrayBufferCallback, 0 } }  ,
+{ "exists"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__existsCallback, 0 } }  ,
+{ "formData"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__formDataCallback, 0 } }  ,
+{ "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__jsonCallback, 0 } }  ,
+{ "lastModified"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BlobPrototype__lastModifiedGetterWrap, 0 } }  ,
+{ "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BlobPrototype__nameGetterWrap, 0 } }  ,
+{ "size"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BlobPrototype__sizeGetterWrap, 0 } }  ,
+{ "slice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__sliceCallback, 2 } }  ,
+{ "stream"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__streamCallback, 1 } }  ,
+{ "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__textCallback, 0 } }  ,
+{ "type"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BlobPrototype__typeGetterWrap, 0 } }  ,
+{ "writer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BlobPrototype__writerCallback, 1 } }
 };
 
+
+
 const ClassInfo JSBlobPrototype::s_info = { "Blob"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBlobPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsBlobConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -1431,124 +1555,130 @@ JSC_DEFINE_CUSTOM_GETTER(jsBlobConstructor, (JSGlobalObject * lexicalGlobalObjec
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Blob"_s);
     return JSValue::encode(globalObject->JSBlobConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(BlobPrototype__arrayBufferCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(BlobPrototype__arrayBufferCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
-        return JSValue::encode({});
-    }
+        JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return BlobPrototype__getArrayBuffer(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BlobPrototype__getArrayBuffer(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BlobPrototype__existsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BlobPrototype__existsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
 
-    JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BlobPrototype__getExists(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BlobPrototype__getExists(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BlobPrototype__formDataCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BlobPrototype__formDataCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
 
-    JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BlobPrototype__getFormData(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BlobPrototype__getFormData(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BlobPrototype__jsonCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BlobPrototype__jsonCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
 
-    JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BlobPrototype__getJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return BlobPrototype__getJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(BlobPrototype__lastModifiedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBlob* thisObject = jsCast<JSBlob*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1556,42 +1686,47 @@ JSC_DEFINE_CUSTOM_GETTER(BlobPrototype__lastModifiedGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(BlobPrototype__nameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBlob* thisObject = jsCast<JSBlob*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_name.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BlobPrototype__getName(thisObject->wrapped(), globalObject));
+        BlobPrototype__getName(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_name.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BlobPrototype__nameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBlob*>(JSValue::decode(thisValue));
-    thisObject->m_name.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BlobPrototype__nameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BlobPrototype__nameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBlob*>(JSValue::decode(thisValue));
+      thisObject->m_name.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BlobPrototype__nameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBlob*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_name.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BlobPrototype__sizeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBlob* thisObject = jsCast<JSBlob*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1599,95 +1734,99 @@ JSC_DEFINE_CUSTOM_GETTER(BlobPrototype__sizeGetterWrap, (JSGlobalObject * lexica
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(BlobPrototype__sliceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(BlobPrototype__sliceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
+        JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return BlobPrototype__getSlice(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BlobPrototype__getSlice(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BlobPrototype__streamCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BlobPrototype__streamCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
 
-    JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BlobPrototype__getStream(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BlobPrototype__getStream(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BlobPrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BlobPrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
 
-    JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BlobPrototype__getText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return BlobPrototype__getText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(BlobPrototype__typeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBlob* thisObject = jsCast<JSBlob*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -1695,34 +1834,36 @@ JSC_DEFINE_CUSTOM_GETTER(BlobPrototype__typeGetterWrap, (JSGlobalObject * lexica
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(BlobPrototype__writerCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(BlobPrototype__writerCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
+        JSBlob* thisObject = jsDynamicCast<JSBlob*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Blob"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return BlobPrototype__getWriter(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return BlobPrototype__getWriter(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 void JSBlobPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -1733,68 +1874,72 @@ void JSBlobPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObj
 
 extern "C" size_t Blob__estimatedSize(void* ptr);
 
+
+
 void JSBlobConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSBlobPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "Blob"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSBlobConstructor::JSBlobConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSBlobConstructor::JSBlobConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSBlobConstructor* JSBlobConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBlobPrototype* prototype)
-{
+  }
+
+JSBlobConstructor* JSBlobConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBlobPrototype* prototype) {
     JSBlobConstructor* ptr = new (NotNull, JSC::allocateCell<JSBlobConstructor>(vm)) JSBlobConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSBlobConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSBlobConstructor();
     Structure* structure = globalObject->JSBlobStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSBlobStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSBlobStructure()
+      );
     }
 
     void* ptr = BlobClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSBlob* instance = JSBlob::create(vm, globalObject, structure, ptr);
-    vm.heap.reportExtraMemoryAllocated(instance, Blob__estimatedSize(instance->wrapped()));
+  vm.heap.reportExtraMemoryAllocated(instance, Blob__estimatedSize(instance->wrapped()));
 
     return JSValue::encode(instance);
 }
 
 void JSBlobConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSBlobPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSBlobConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBlobConstructor) };
 
-extern "C" EncodedJSValue Blob__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue Blob__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSBlobConstructor());
-}
+  }
 
 JSBlob::~JSBlob()
 {
@@ -1806,7 +1951,7 @@ void JSBlob::destroy(JSCell* cell)
 {
     static_cast<JSBlob*>(cell)->JSBlob::~JSBlob();
 }
-
+  
 const ClassInfo JSBlob::s_info = { "Blob"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBlob) };
 
 void JSBlob::finishCreation(VM& vm)
@@ -1815,38 +1960,37 @@ void JSBlob::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSBlob* JSBlob::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSBlob* ptr = new (NotNull, JSC::allocateCell<JSBlob>(vm)) JSBlob(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Blob__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSBlob* JSBlob::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSBlob* ptr = new (NotNull, JSC::allocateCell<JSBlob>(vm)) JSBlob(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSBlob* object = JSC::jsDynamicCast<JSBlob*>(cell);
+extern "C" void* Blob__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSBlob* object = JSC::jsDynamicCast<JSBlob*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Blob__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSBlob* object = JSC::jsDynamicCast<JSBlob*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Blob__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSBlob* object = JSC::jsDynamicCast<JSBlob*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Blob__ptrOffset = JSBlob::offsetOfWrapped();
 
 void JSBlob::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -1861,7 +2005,7 @@ void JSBlob::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSBlob::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSBlobConstructor::create(vm, globalObject, WebCore::JSBlobConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSBlobPrototype*>(prototype));
+  return WebCore::JSBlobConstructor::create(vm, globalObject, WebCore::JSBlobConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSBlobPrototype*>(prototype));
 }
 
 JSObject* JSBlob::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -1869,13 +2013,12 @@ JSObject* JSBlob::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSBlobPrototype::create(vm, globalObject, JSBlobPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Blob__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSBlobStructure();
-    JSBlob* instance = JSBlob::create(vm, globalObject, structure, ptr);
-    vm.heap.reportExtraMemoryAllocated(instance, Blob__estimatedSize(ptr));
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Blob__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSBlobStructure();
+  JSBlob* instance = JSBlob::create(vm, globalObject, structure, ptr);
+  vm.heap.reportExtraMemoryAllocated(instance, Blob__estimatedSize(ptr));
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -1885,8 +2028,8 @@ void JSBlob::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
     if (auto* ptr = thisObject->wrapped()) {
-        visitor.reportExtraMemoryVisited(Blob__estimatedSize(ptr));
-    }
+visitor.reportExtraMemoryVisited(Blob__estimatedSize(ptr));
+}
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -1895,16 +2038,17 @@ DEFINE_VISIT_CHILDREN(JSBlob);
 template<typename Visitor>
 void JSBlob::visitAdditionalChildren(Visitor& visitor)
 {
-    JSBlob* thisObject = this;
+  JSBlob* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_name);
+    
+        visitor.append(thisObject->m_name);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSBlob);
 
 template<typename Visitor>
-void JSBlob::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSBlob::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSBlob* thisObject = jsCast<JSBlob*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -1912,279 +2056,314 @@ void JSBlob::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSBlob);
-class JSBuildArtifactPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSBuildArtifactPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSBuildArtifactPrototype* ptr = new (NotNull, JSC::allocateCell<JSBuildArtifactPrototype>(vm)) JSBuildArtifactPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBuildArtifactPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSBuildArtifactPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSBuildArtifactPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSBuildArtifactPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSBuildArtifactPrototype* ptr = new (NotNull, JSC::allocateCell<JSBuildArtifactPrototype>(vm)) JSBuildArtifactPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBuildArtifactPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSBuildArtifactPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 extern "C" void BuildArtifactClass__finalize(void*);
 
+
 extern "C" EncodedJSValue BuildArtifactPrototype__getArrayBuffer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BuildArtifactPrototype__arrayBufferCallback);
 
+
 extern "C" JSC::EncodedJSValue BuildArtifactPrototype__getHash(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildArtifactPrototype__hashGetterWrap);
 
+
 extern "C" EncodedJSValue BuildArtifactPrototype__getJSON(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BuildArtifactPrototype__jsonCallback);
 
+
 extern "C" JSC::EncodedJSValue BuildArtifactPrototype__getOutputKind(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildArtifactPrototype__kindGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BuildArtifactPrototype__getLoader(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildArtifactPrototype__loaderGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BuildArtifactPrototype__getPath(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildArtifactPrototype__pathGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BuildArtifactPrototype__getSize(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildArtifactPrototype__sizeGetterWrap);
 
+
 extern "C" EncodedJSValue BuildArtifactPrototype__getSlice(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BuildArtifactPrototype__sliceCallback);
 
+
 extern "C" JSC::EncodedJSValue BuildArtifactPrototype__getSourceMap(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildArtifactPrototype__sourcemapGetterWrap);
 
+
 extern "C" EncodedJSValue BuildArtifactPrototype__getStream(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BuildArtifactPrototype__streamCallback);
 
+
 extern "C" EncodedJSValue BuildArtifactPrototype__getText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BuildArtifactPrototype__textCallback);
 
+
 extern "C" JSC::EncodedJSValue BuildArtifactPrototype__getMimeType(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildArtifactPrototype__typeGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBuildArtifactPrototype, JSBuildArtifactPrototype::Base);
 
-static const HashTableValue JSBuildArtifactPrototypeTableValues[] = {
-    { "arrayBuffer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__arrayBufferCallback, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__hashGetterWrap, 0 } },
-    { "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__jsonCallback, 0 } },
-    { "kind"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__kindGetterWrap, 0 } },
-    { "loader"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__loaderGetterWrap, 0 } },
-    { "path"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__pathGetterWrap, 0 } },
-    { "size"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__sizeGetterWrap, 0 } },
-    { "slice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__sliceCallback, 2 } },
-    { "sourcemap"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__sourcemapGetterWrap, 0 } },
-    { "stream"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__streamCallback, 1 } },
-    { "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__textCallback, 0 } },
-    { "type"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__typeGetterWrap, 0 } }
+
+  static const HashTableValue JSBuildArtifactPrototypeTableValues[] = {
+{ "arrayBuffer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__arrayBufferCallback, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__hashGetterWrap, 0 } }  ,
+{ "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__jsonCallback, 0 } }  ,
+{ "kind"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__kindGetterWrap, 0 } }  ,
+{ "loader"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__loaderGetterWrap, 0 } }  ,
+{ "path"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__pathGetterWrap, 0 } }  ,
+{ "size"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__sizeGetterWrap, 0 } }  ,
+{ "slice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__sliceCallback, 2 } }  ,
+{ "sourcemap"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__sourcemapGetterWrap, 0 } }  ,
+{ "stream"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__streamCallback, 1 } }  ,
+{ "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildArtifactPrototype__textCallback, 0 } }  ,
+{ "type"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildArtifactPrototype__typeGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSBuildArtifactPrototype::s_info = { "BuildArtifact"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBuildArtifactPrototype) };
 
-JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__arrayBufferCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__arrayBufferCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
-        return JSValue::encode({});
-    }
+        JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    return BuildArtifactPrototype__getArrayBuffer(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return BuildArtifactPrototype__getArrayBuffer(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(BuildArtifactPrototype__hashGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_hash.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildArtifactPrototype__getHash(thisObject->wrapped(), globalObject));
+        BuildArtifactPrototype__getHash(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_hash.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildArtifactPrototype__hashSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    thisObject->m_hash.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildArtifactPrototype__hashGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildArtifactPrototype__hashSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
+      thisObject->m_hash.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildArtifactPrototype__hashGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_hash.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__jsonCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__jsonCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
+        JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return BuildArtifactPrototype__getJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return BuildArtifactPrototype__getJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(BuildArtifactPrototype__kindGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_kind.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildArtifactPrototype__getOutputKind(thisObject->wrapped(), globalObject));
+        BuildArtifactPrototype__getOutputKind(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_kind.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildArtifactPrototype__kindSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    thisObject->m_kind.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildArtifactPrototype__kindGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildArtifactPrototype__kindSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
+      thisObject->m_kind.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildArtifactPrototype__kindGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_kind.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BuildArtifactPrototype__loaderGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_loader.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildArtifactPrototype__getLoader(thisObject->wrapped(), globalObject));
+        BuildArtifactPrototype__getLoader(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_loader.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildArtifactPrototype__loaderSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    thisObject->m_loader.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildArtifactPrototype__loaderGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildArtifactPrototype__loaderSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
+      thisObject->m_loader.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildArtifactPrototype__loaderGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_loader.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BuildArtifactPrototype__pathGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_path.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildArtifactPrototype__getPath(thisObject->wrapped(), globalObject));
+        BuildArtifactPrototype__getPath(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_path.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildArtifactPrototype__pathSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    thisObject->m_path.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildArtifactPrototype__pathGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildArtifactPrototype__pathSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
+      thisObject->m_path.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildArtifactPrototype__pathGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_path.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BuildArtifactPrototype__sizeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -2192,152 +2371,164 @@ JSC_DEFINE_CUSTOM_GETTER(BuildArtifactPrototype__sizeGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__sliceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__sliceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
+        JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return BuildArtifactPrototype__getSlice(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return BuildArtifactPrototype__getSlice(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(BuildArtifactPrototype__sourcemapGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_sourcemap.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildArtifactPrototype__getSourceMap(thisObject->wrapped(), globalObject));
+        BuildArtifactPrototype__getSourceMap(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_sourcemap.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildArtifactPrototype__sourcemapSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    thisObject->m_sourcemap.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildArtifactPrototype__sourcemapGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildArtifactPrototype__sourcemapSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
+      thisObject->m_sourcemap.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildArtifactPrototype__sourcemapGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_sourcemap.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__streamCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__streamCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
+        JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return BuildArtifactPrototype__getStream(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BuildArtifactPrototype__getStream(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BuildArtifactPrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
 
-    JSBuildArtifact* thisObject = jsDynamicCast<JSBuildArtifact*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildArtifact"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BuildArtifactPrototype__getText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return BuildArtifactPrototype__getText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(BuildArtifactPrototype__typeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_type.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildArtifactPrototype__getMimeType(thisObject->wrapped(), globalObject));
+        BuildArtifactPrototype__getMimeType(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_type.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildArtifactPrototype__typeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
-    thisObject->m_type.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildArtifactPrototype__typeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildArtifactPrototype__typeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
+      thisObject->m_type.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildArtifactPrototype__typeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildArtifact*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_type.get());
-}
+  }
+  
+  
 
 void JSBuildArtifactPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -2356,7 +2547,7 @@ void JSBuildArtifact::destroy(JSCell* cell)
 {
     static_cast<JSBuildArtifact*>(cell)->JSBuildArtifact::~JSBuildArtifact();
 }
-
+  
 const ClassInfo JSBuildArtifact::s_info = { "BuildArtifact"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBuildArtifact) };
 
 void JSBuildArtifact::finishCreation(VM& vm)
@@ -2365,38 +2556,37 @@ void JSBuildArtifact::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSBuildArtifact* JSBuildArtifact::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSBuildArtifact* ptr = new (NotNull, JSC::allocateCell<JSBuildArtifact>(vm)) JSBuildArtifact(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* BuildArtifact__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSBuildArtifact* JSBuildArtifact::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSBuildArtifact* ptr = new (NotNull, JSC::allocateCell<JSBuildArtifact>(vm)) JSBuildArtifact(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSBuildArtifact* object = JSC::jsDynamicCast<JSBuildArtifact*>(cell);
+extern "C" void* BuildArtifact__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSBuildArtifact* object = JSC::jsDynamicCast<JSBuildArtifact*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool BuildArtifact__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSBuildArtifact* object = JSC::jsDynamicCast<JSBuildArtifact*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool BuildArtifact__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSBuildArtifact* object = JSC::jsDynamicCast<JSBuildArtifact*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t BuildArtifact__ptrOffset = JSBuildArtifact::offsetOfWrapped();
 
 void JSBuildArtifact::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -2409,18 +2599,19 @@ void JSBuildArtifact::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSBuildArtifact::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSBuildArtifactPrototype::create(vm, globalObject, JSBuildArtifactPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue BuildArtifact__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSBuildArtifactStructure();
-    JSBuildArtifact* instance = JSBuildArtifact::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue BuildArtifact__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSBuildArtifactStructure();
+  JSBuildArtifact* instance = JSBuildArtifact::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -2429,7 +2620,7 @@ void JSBuildArtifact::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -2438,21 +2629,22 @@ DEFINE_VISIT_CHILDREN(JSBuildArtifact);
 template<typename Visitor>
 void JSBuildArtifact::visitAdditionalChildren(Visitor& visitor)
 {
-    JSBuildArtifact* thisObject = this;
+  JSBuildArtifact* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_hash);
+    
+        visitor.append(thisObject->m_hash);
     visitor.append(thisObject->m_kind);
     visitor.append(thisObject->m_loader);
     visitor.append(thisObject->m_path);
     visitor.append(thisObject->m_sourcemap);
     visitor.append(thisObject->m_type);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSBuildArtifact);
 
 template<typename Visitor>
-void JSBuildArtifact::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSBuildArtifact::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSBuildArtifact* thisObject = jsCast<JSBuildArtifact*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -2460,110 +2652,127 @@ void JSBuildArtifact::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSBuildArtifact);
-class JSBuildMessagePrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSBuildMessagePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSBuildMessagePrototype* ptr = new (NotNull, JSC::allocateCell<JSBuildMessagePrototype>(vm)) JSBuildMessagePrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBuildMessagePrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSBuildMessagePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSBuildMessagePrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSBuildMessagePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSBuildMessagePrototype* ptr = new (NotNull, JSC::allocateCell<JSBuildMessagePrototype>(vm)) JSBuildMessagePrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBuildMessagePrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSBuildMessagePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSBuildMessageConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSBuildMessageConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBuildMessagePrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
+    public:
+        using Base = JSC::InternalFunction;
+        static JSBuildMessageConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBuildMessagePrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSBuildMessageConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForBuildMessageConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBuildMessageConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForBuildMessageConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForBuildMessageConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSBuildMessagePrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSBuildMessageConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSBuildMessagePrototype* prototype);
+    };
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSBuildMessageConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForBuildMessageConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBuildMessageConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForBuildMessageConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForBuildMessageConstructor = std::forward<decltype(space)>(space); });
-    }
+extern "C" void* BuildMessageClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsBuildMessageConstructor);
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSBuildMessagePrototype* prototype);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSBuildMessageConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSBuildMessagePrototype* prototype);
-};
-
-extern "C" void* BuildMessageClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsBuildMessageConstructor);
 
 extern "C" void BuildMessageClass__finalize(void*);
 
+
 extern "C" EncodedJSValue BuildMessagePrototype__toPrimitive(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BuildMessagePrototype__toPrimitiveCallback);
 
+
 extern "C" JSC::EncodedJSValue BuildMessagePrototype__getLevel(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildMessagePrototype__levelGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BuildMessagePrototype__getMessage(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildMessagePrototype__messageGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue BuildMessagePrototype__getPosition(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(BuildMessagePrototype__positionGetterWrap);
 
+
 extern "C" EncodedJSValue BuildMessagePrototype__toJSON(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BuildMessagePrototype__toJSONCallback);
 
+
 extern "C" EncodedJSValue BuildMessagePrototype__toString(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(BuildMessagePrototype__toStringCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSBuildMessagePrototype, JSBuildMessagePrototype::Base);
 
-static const HashTableValue JSBuildMessagePrototypeTableValues[] = {
-    { "level"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildMessagePrototype__levelGetterWrap, 0 } },
-    { "message"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildMessagePrototype__messageGetterWrap, 0 } },
-    { "position"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildMessagePrototype__positionGetterWrap, 0 } },
-    { "toJSON"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildMessagePrototype__toJSONCallback, 0 } },
-    { "toString"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildMessagePrototype__toStringCallback, 0 } }
+
+  static const HashTableValue JSBuildMessagePrototypeTableValues[] = {
+{ "level"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildMessagePrototype__levelGetterWrap, 0 } }  ,
+{ "message"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildMessagePrototype__messageGetterWrap, 0 } }  ,
+{ "position"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, BuildMessagePrototype__positionGetterWrap, 0 } }  ,
+{ "toJSON"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildMessagePrototype__toJSONCallback, 0 } }  ,
+{ "toString"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, BuildMessagePrototype__toStringCallback, 0 } }
 };
 
+
+
 const ClassInfo JSBuildMessagePrototype::s_info = { "BuildMessage"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBuildMessagePrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsBuildMessageConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -2574,255 +2783,275 @@ JSC_DEFINE_CUSTOM_GETTER(jsBuildMessageConstructor, (JSGlobalObject * lexicalGlo
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for BuildMessage"_s);
     return JSValue::encode(globalObject->JSBuildMessageConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(BuildMessagePrototype__toPrimitiveCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSBuildMessage* thisObject = jsDynamicCast<JSBuildMessage*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(BuildMessagePrototype__toPrimitiveCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSBuildMessage* thisObject = jsDynamicCast<JSBuildMessage*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildMessage"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildMessage"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return BuildMessagePrototype__toPrimitive(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return BuildMessagePrototype__toPrimitive(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(BuildMessagePrototype__levelGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildMessage* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_level.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildMessagePrototype__getLevel(thisObject->wrapped(), globalObject));
+        BuildMessagePrototype__getLevel(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_level.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildMessagePrototype__levelSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
-    thisObject->m_level.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildMessagePrototype__levelGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildMessagePrototype__levelSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
+      thisObject->m_level.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildMessagePrototype__levelGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_level.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BuildMessagePrototype__messageGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildMessage* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_message.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildMessagePrototype__getMessage(thisObject->wrapped(), globalObject));
+        BuildMessagePrototype__getMessage(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_message.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildMessagePrototype__messageSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
-    thisObject->m_message.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildMessagePrototype__messageGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildMessagePrototype__messageSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
+      thisObject->m_message.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildMessagePrototype__messageGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_message.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(BuildMessagePrototype__positionGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSBuildMessage* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_position.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        BuildMessagePrototype__getPosition(thisObject->wrapped(), globalObject));
+        BuildMessagePrototype__getPosition(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_position.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void BuildMessagePrototype__positionSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
-    thisObject->m_position.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue BuildMessagePrototype__positionGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void BuildMessagePrototype__positionSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
+      thisObject->m_position.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue BuildMessagePrototype__positionGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSBuildMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_position.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(BuildMessagePrototype__toJSONCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(BuildMessagePrototype__toJSONCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSBuildMessage* thisObject = jsDynamicCast<JSBuildMessage*>(callFrame->thisValue());
+        JSBuildMessage* thisObject = jsDynamicCast<JSBuildMessage*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildMessage"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildMessage"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BuildMessagePrototype__toJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return BuildMessagePrototype__toJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(BuildMessagePrototype__toStringCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(BuildMessagePrototype__toStringCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSBuildMessage* thisObject = jsDynamicCast<JSBuildMessage*>(callFrame->thisValue());
 
-    JSBuildMessage* thisObject = jsDynamicCast<JSBuildMessage*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildMessage"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof BuildMessage"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return BuildMessagePrototype__toString(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return BuildMessagePrototype__toString(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSBuildMessagePrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
     reifyStaticProperties(vm, JSBuildMessage::info(), JSBuildMessagePrototypeTableValues, *this);
     this->putDirect(vm, vm.propertyNames->toPrimitiveSymbol, JSFunction::create(vm, globalObject, 1, String("toPrimitive"_s), BuildMessagePrototype__toPrimitiveCallback, ImplementationVisibility::Public), PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum | 0);
-    this->putDirect(vm, vm.propertyNames->name, jsString(vm, String("BuildMessage"_s)), PropertyAttribute::ReadOnly | 0);
+      this->putDirect(vm, vm.propertyNames->name, jsString(vm, String("BuildMessage"_s)), PropertyAttribute::ReadOnly | 0);
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
 void JSBuildMessageConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSBuildMessagePrototype* prototype)
 {
     Base::finishCreation(vm, 0, "BuildMessage"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSBuildMessageConstructor::JSBuildMessageConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSBuildMessageConstructor::JSBuildMessageConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSBuildMessageConstructor* JSBuildMessageConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBuildMessagePrototype* prototype)
-{
+  }
+
+JSBuildMessageConstructor* JSBuildMessageConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSBuildMessagePrototype* prototype) {
     JSBuildMessageConstructor* ptr = new (NotNull, JSC::allocateCell<JSBuildMessageConstructor>(vm)) JSBuildMessageConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSBuildMessageConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSBuildMessageConstructor();
     Structure* structure = globalObject->JSBuildMessageStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSBuildMessageStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSBuildMessageStructure()
+      );
     }
 
     void* ptr = BuildMessageClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSBuildMessage* instance = JSBuildMessage::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSBuildMessageConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSBuildMessagePrototype* prototype)
 {
+
 }
 
 const ClassInfo JSBuildMessageConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBuildMessageConstructor) };
 
-extern "C" EncodedJSValue BuildMessage__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue BuildMessage__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSBuildMessageConstructor());
-}
+  }
 
 JSBuildMessage::~JSBuildMessage()
 {
@@ -2834,7 +3063,7 @@ void JSBuildMessage::destroy(JSCell* cell)
 {
     static_cast<JSBuildMessage*>(cell)->JSBuildMessage::~JSBuildMessage();
 }
-
+  
 const ClassInfo JSBuildMessage::s_info = { "BuildMessage"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSBuildMessage) };
 
 void JSBuildMessage::finishCreation(VM& vm)
@@ -2843,38 +3072,37 @@ void JSBuildMessage::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSBuildMessage* JSBuildMessage::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSBuildMessage* ptr = new (NotNull, JSC::allocateCell<JSBuildMessage>(vm)) JSBuildMessage(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* BuildMessage__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSBuildMessage* JSBuildMessage::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSBuildMessage* ptr = new (NotNull, JSC::allocateCell<JSBuildMessage>(vm)) JSBuildMessage(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSBuildMessage* object = JSC::jsDynamicCast<JSBuildMessage*>(cell);
+extern "C" void* BuildMessage__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSBuildMessage* object = JSC::jsDynamicCast<JSBuildMessage*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool BuildMessage__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSBuildMessage* object = JSC::jsDynamicCast<JSBuildMessage*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool BuildMessage__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSBuildMessage* object = JSC::jsDynamicCast<JSBuildMessage*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t BuildMessage__ptrOffset = JSBuildMessage::offsetOfWrapped();
 
 void JSBuildMessage::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -2889,7 +3117,7 @@ void JSBuildMessage::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSBuildMessage::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSBuildMessageConstructor::create(vm, globalObject, WebCore::JSBuildMessageConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSBuildMessagePrototype*>(prototype));
+  return WebCore::JSBuildMessageConstructor::create(vm, globalObject, WebCore::JSBuildMessageConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSBuildMessagePrototype*>(prototype));
 }
 
 JSObject* JSBuildMessage::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -2897,13 +3125,12 @@ JSObject* JSBuildMessage::createPrototype(VM& vm, JSDOMGlobalObject* globalObjec
     return JSBuildMessagePrototype::create(vm, globalObject, JSBuildMessagePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue BuildMessage__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSBuildMessageStructure();
-    JSBuildMessage* instance = JSBuildMessage::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue BuildMessage__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSBuildMessageStructure();
+  JSBuildMessage* instance = JSBuildMessage::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -2912,7 +3139,7 @@ void JSBuildMessage::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSBuildMessage* thisObject = jsCast<JSBuildMessage*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -2921,18 +3148,19 @@ DEFINE_VISIT_CHILDREN(JSBuildMessage);
 template<typename Visitor>
 void JSBuildMessage::visitAdditionalChildren(Visitor& visitor)
 {
-    JSBuildMessage* thisObject = this;
+  JSBuildMessage* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_level);
+    
+        visitor.append(thisObject->m_level);
     visitor.append(thisObject->m_message);
     visitor.append(thisObject->m_position);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSBuildMessage);
 
 template<typename Visitor>
-void JSBuildMessage::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSBuildMessage::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSBuildMessage* thisObject = jsCast<JSBuildMessage*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -2940,77 +3168,94 @@ void JSBuildMessage::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSBuildMessage);
-class JSCommentPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSCommentPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSCommentPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSCommentPrototype* ptr = new (NotNull, JSC::allocateCell<JSCommentPrototype>(vm)) JSCommentPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCommentPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSCommentPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSCommentPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSCommentPrototype* ptr = new (NotNull, JSC::allocateCell<JSCommentPrototype>(vm)) JSCommentPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* CommentClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsCommentConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCommentPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSCommentPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* CommentClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsCommentConstructor);
 
 extern "C" void CommentClass__finalize(void*);
 
+
 extern "C" EncodedJSValue CommentPrototype__after(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CommentPrototype__afterCallback);
 
+
 extern "C" EncodedJSValue CommentPrototype__before(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CommentPrototype__beforeCallback);
 
+
 extern "C" EncodedJSValue CommentPrototype__remove(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CommentPrototype__removeCallback);
 
+
 extern "C" JSC::EncodedJSValue CommentPrototype__removed(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(CommentPrototype__removedGetterWrap);
 
+
 extern "C" EncodedJSValue CommentPrototype__replace(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CommentPrototype__replaceCallback);
 
+
 extern "C" JSC::EncodedJSValue CommentPrototype__getText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(CommentPrototype__textGetterWrap);
 
+
 extern "C" bool CommentPrototype__setText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
 JSC_DECLARE_CUSTOM_SETTER(CommentPrototype__textSetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCommentPrototype, JSCommentPrototype::Base);
 
-static const HashTableValue JSCommentPrototypeTableValues[] = {
-    { "after"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CommentPrototype__afterCallback, 1 } },
-    { "before"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CommentPrototype__beforeCallback, 1 } },
-    { "remove"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CommentPrototype__removeCallback, 0 } },
-    { "removed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CommentPrototype__removedGetterWrap, 0 } },
-    { "replace"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CommentPrototype__replaceCallback, 1 } },
-    { "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CommentPrototype__textGetterWrap, CommentPrototype__textSetterWrap } }
+
+  static const HashTableValue JSCommentPrototypeTableValues[] = {
+{ "after"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CommentPrototype__afterCallback, 1 } }  ,
+{ "before"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CommentPrototype__beforeCallback, 1 } }  ,
+{ "remove"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CommentPrototype__removeCallback, 0 } }  ,
+{ "removed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CommentPrototype__removedGetterWrap, 0 } }  ,
+{ "replace"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CommentPrototype__replaceCallback, 1 } }  ,
+{ "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CommentPrototype__textGetterWrap, CommentPrototype__textSetterWrap } }
 };
 
+
+
 const ClassInfo JSCommentPrototype::s_info = { "Comment"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCommentPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsCommentConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -3021,96 +3266,101 @@ JSC_DEFINE_CUSTOM_GETTER(jsCommentConstructor, (JSGlobalObject * lexicalGlobalOb
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Comment"_s);
     return JSValue::encode(globalObject->JSCommentConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(CommentPrototype__afterCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSComment* thisObject = jsDynamicCast<JSComment*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(CommentPrototype__afterCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSComment* thisObject = jsDynamicCast<JSComment*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Comment"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Comment"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return CommentPrototype__after(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return CommentPrototype__after(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(CommentPrototype__beforeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(CommentPrototype__beforeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSComment* thisObject = jsDynamicCast<JSComment*>(callFrame->thisValue());
 
-    JSComment* thisObject = jsDynamicCast<JSComment*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Comment"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Comment"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CommentPrototype__before(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return CommentPrototype__before(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(CommentPrototype__removeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(CommentPrototype__removeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSComment* thisObject = jsDynamicCast<JSComment*>(callFrame->thisValue());
 
-    JSComment* thisObject = jsDynamicCast<JSComment*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Comment"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Comment"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CommentPrototype__remove(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return CommentPrototype__remove(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(CommentPrototype__removedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSComment* thisObject = jsCast<JSComment*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -3118,39 +3368,41 @@ JSC_DEFINE_CUSTOM_GETTER(CommentPrototype__removedGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(CommentPrototype__replaceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(CommentPrototype__replaceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSComment* thisObject = jsDynamicCast<JSComment*>(callFrame->thisValue());
+        JSComment* thisObject = jsDynamicCast<JSComment*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Comment"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Comment"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return CommentPrototype__replace(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return CommentPrototype__replace(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(CommentPrototype__textGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSComment* thisObject = jsCast<JSComment*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -3158,6 +3410,7 @@ JSC_DEFINE_CUSTOM_GETTER(CommentPrototype__textGetterWrap, (JSGlobalObject * lex
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_SETTER(CommentPrototype__textSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
 {
@@ -3170,6 +3423,7 @@ JSC_DEFINE_CUSTOM_SETTER(CommentPrototype__textSetterWrap, (JSGlobalObject * lex
     RELEASE_AND_RETURN(throwScope, result);
 }
 
+
 void JSCommentPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
@@ -3187,7 +3441,7 @@ void JSComment::destroy(JSCell* cell)
 {
     static_cast<JSComment*>(cell)->JSComment::~JSComment();
 }
-
+  
 const ClassInfo JSComment::s_info = { "Comment"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSComment) };
 
 void JSComment::finishCreation(VM& vm)
@@ -3196,38 +3450,37 @@ void JSComment::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSComment* JSComment::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSComment* ptr = new (NotNull, JSC::allocateCell<JSComment>(vm)) JSComment(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Comment__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSComment* JSComment::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSComment* ptr = new (NotNull, JSC::allocateCell<JSComment>(vm)) JSComment(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSComment* object = JSC::jsDynamicCast<JSComment*>(cell);
+extern "C" void* Comment__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSComment* object = JSC::jsDynamicCast<JSComment*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Comment__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSComment* object = JSC::jsDynamicCast<JSComment*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Comment__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSComment* object = JSC::jsDynamicCast<JSComment*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Comment__ptrOffset = JSComment::offsetOfWrapped();
 
 void JSComment::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -3240,103 +3493,111 @@ void JSComment::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSComment::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSCommentPrototype::create(vm, globalObject, JSCommentPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Comment__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSCommentStructure();
-    JSComment* instance = JSComment::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSCryptoPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSCryptoPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSCryptoPrototype* ptr = new (NotNull, JSC::allocateCell<JSCryptoPrototype>(vm)) JSCryptoPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCryptoPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSCryptoPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue Comment__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSCommentStructure();
+  JSComment* instance = JSComment::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSCryptoPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSCryptoPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSCryptoPrototype* ptr = new (NotNull, JSC::allocateCell<JSCryptoPrototype>(vm)) JSCryptoPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCryptoPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSCryptoPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSCryptoConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSCryptoConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSCryptoPrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
+    public:
+        using Base = JSC::InternalFunction;
+        static JSCryptoConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSCryptoPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSCryptoConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForCryptoConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForCryptoConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForCryptoConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSCryptoPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSCryptoConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSCryptoPrototype* prototype);
+    };
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSCryptoConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForCryptoConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForCryptoConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForCryptoConstructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSCryptoPrototype* prototype);
+extern "C" void* CryptoClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsCryptoConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSCryptoConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSCryptoPrototype* prototype);
-};
 
-extern "C" void* CryptoClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsCryptoConstructor);
 
 extern "C" void CryptoClass__finalize(void*);
 
+
 extern "C" EncodedJSValue CryptoPrototype__getRandomValues(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CryptoPrototype__getRandomValuesCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(CryptoPrototype__getRandomValuesWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSUint8Array* arg0));
-extern "C" EncodedJSValue CryptoPrototype__getRandomValuesWithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSUint8Array* arg0);
+  extern "C" EncodedJSValue CryptoPrototype__getRandomValuesWithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject, JSC::JSUint8Array* arg0);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForCryptoPrototype__getRandomValues(CryptoPrototype__getRandomValuesWithoutTypeChecksWrapper,
-    JSCrypto::info(),
-    JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()),
-    JSC::SpecHeapTop, JSC::SpecUint8Array);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForCryptoPrototype__getRandomValues(CryptoPrototype__getRandomValuesWithoutTypeChecksWrapper, 
+  JSCrypto::info(), 
+  JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), 
+  JSC::SpecHeapTop, JSC::SpecUint8Array);
 
 JSC_DEFINE_JIT_OPERATION(CryptoPrototype__getRandomValuesWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSUint8Array* arg0))
 {
@@ -3351,16 +3612,18 @@ JSC_DEFINE_JIT_OPERATION(CryptoPrototype__getRandomValuesWithoutTypeChecksWrappe
 extern "C" EncodedJSValue CryptoPrototype__randomInt(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CryptoPrototype__randomIntCallback);
 
+
 extern "C" EncodedJSValue CryptoPrototype__randomUUID(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CryptoPrototype__randomUUIDCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(CryptoPrototype__randomUUIDWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue CryptoPrototype__randomUUIDWithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue CryptoPrototype__randomUUIDWithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForCryptoPrototype__randomUUID(CryptoPrototype__randomUUIDWithoutTypeChecksWrapper,
-    JSCrypto::info(),
-    JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()),
-    JSC::SpecString);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForCryptoPrototype__randomUUID(CryptoPrototype__randomUUIDWithoutTypeChecksWrapper, 
+  JSCrypto::info(), 
+  JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), 
+  JSC::SpecString);
 
 JSC_DEFINE_JIT_OPERATION(CryptoPrototype__randomUUIDWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -3375,16 +3638,18 @@ JSC_DEFINE_JIT_OPERATION(CryptoPrototype__randomUUIDWithoutTypeChecksWrapper, En
 extern "C" EncodedJSValue CryptoPrototype__doScryptSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CryptoPrototype__scryptSyncCallback);
 
+
 extern "C" EncodedJSValue CryptoPrototype__timingSafeEqual(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CryptoPrototype__timingSafeEqualCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(CryptoPrototype__timingSafeEqualWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSUint8Array* arg0, JSC::JSUint8Array* arg1));
-extern "C" EncodedJSValue CryptoPrototype__timingSafeEqualWithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSUint8Array* arg0, JSC::JSUint8Array* arg1);
+  extern "C" EncodedJSValue CryptoPrototype__timingSafeEqualWithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject, JSC::JSUint8Array* arg0, JSC::JSUint8Array* arg1);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForCryptoPrototype__timingSafeEqual(CryptoPrototype__timingSafeEqualWithoutTypeChecksWrapper,
-    JSCrypto::info(),
-    JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()),
-    JSC::SpecHeapTop, JSC::SpecUint8Array, JSC::SpecUint8Array);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForCryptoPrototype__timingSafeEqual(CryptoPrototype__timingSafeEqualWithoutTypeChecksWrapper, 
+  JSCrypto::info(), 
+  JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), 
+  JSC::SpecHeapTop, JSC::SpecUint8Array, JSC::SpecUint8Array);
 
 JSC_DEFINE_JIT_OPERATION(CryptoPrototype__timingSafeEqualWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSUint8Array* arg0, JSC::JSUint8Array* arg1))
 {
@@ -3398,16 +3663,21 @@ JSC_DEFINE_JIT_OPERATION(CryptoPrototype__timingSafeEqualWithoutTypeChecksWrappe
 
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCryptoPrototype, JSCryptoPrototype::Base);
 
-static const HashTableValue JSCryptoPrototypeTableValues[] = {
-    { "getRandomValues"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, CryptoPrototype__getRandomValuesCallback, &DOMJITSignatureForCryptoPrototype__getRandomValues } },
-    { "randomInt"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoPrototype__randomIntCallback, 2 } },
-    { "randomUUID"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, CryptoPrototype__randomUUIDCallback, &DOMJITSignatureForCryptoPrototype__randomUUID } },
-    { "scryptSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoPrototype__scryptSyncCallback, 2 } },
-    { "timingSafeEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, CryptoPrototype__timingSafeEqualCallback, &DOMJITSignatureForCryptoPrototype__timingSafeEqual } }
+
+  static const HashTableValue JSCryptoPrototypeTableValues[] = {
+{ "getRandomValues"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, CryptoPrototype__getRandomValuesCallback, &DOMJITSignatureForCryptoPrototype__getRandomValues } }  ,
+{ "randomInt"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoPrototype__randomIntCallback, 2 } }  ,
+{ "randomUUID"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, CryptoPrototype__randomUUIDCallback, &DOMJITSignatureForCryptoPrototype__randomUUID } }  ,
+{ "scryptSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoPrototype__scryptSyncCallback, 2 } }  ,
+{ "timingSafeEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, CryptoPrototype__timingSafeEqualCallback, &DOMJITSignatureForCryptoPrototype__timingSafeEqual } }
 };
 
+
+
 const ClassInfo JSCryptoPrototype::s_info = { "Crypto"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCryptoPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsCryptoConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -3418,147 +3688,154 @@ JSC_DEFINE_CUSTOM_GETTER(jsCryptoConstructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Crypto"_s);
     return JSValue::encode(globalObject->JSCryptoConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__getRandomValuesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__getRandomValuesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
-        return JSValue::encode({});
-    }
+        JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CryptoPrototype__getRandomValues(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return CryptoPrototype__getRandomValues(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__randomIntCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__randomIntCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
 
-    JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CryptoPrototype__randomInt(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return CryptoPrototype__randomInt(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__randomUUIDCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__randomUUIDCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
 
-    JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CryptoPrototype__randomUUID(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return CryptoPrototype__randomUUID(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__scryptSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__scryptSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
 
-    JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CryptoPrototype__doScryptSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return CryptoPrototype__doScryptSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__timingSafeEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(CryptoPrototype__timingSafeEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
 
-    JSCrypto* thisObject = jsDynamicCast<JSCrypto*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Crypto"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CryptoPrototype__timingSafeEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return CryptoPrototype__timingSafeEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSCryptoPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -3570,64 +3847,67 @@ void JSCryptoPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalO
 void JSCryptoConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSCryptoPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "Crypto"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSCryptoConstructor::JSCryptoConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSCryptoConstructor::JSCryptoConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSCryptoConstructor* JSCryptoConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSCryptoPrototype* prototype)
-{
+  }
+
+JSCryptoConstructor* JSCryptoConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSCryptoPrototype* prototype) {
     JSCryptoConstructor* ptr = new (NotNull, JSC::allocateCell<JSCryptoConstructor>(vm)) JSCryptoConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSCryptoConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSCryptoConstructor();
     Structure* structure = globalObject->JSCryptoStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSCryptoStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSCryptoStructure()
+      );
     }
 
     void* ptr = CryptoClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSCrypto* instance = JSCrypto::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSCryptoConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSCryptoPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSCryptoConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCryptoConstructor) };
 
-extern "C" EncodedJSValue Crypto__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue Crypto__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSCryptoConstructor());
-}
+  }
 
 JSCrypto::~JSCrypto()
 {
@@ -3636,7 +3916,7 @@ void JSCrypto::destroy(JSCell* cell)
 {
     static_cast<JSCrypto*>(cell)->JSCrypto::~JSCrypto();
 }
-
+  
 const ClassInfo JSCrypto::s_info = { "Crypto"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCrypto) };
 
 void JSCrypto::finishCreation(VM& vm)
@@ -3645,38 +3925,37 @@ void JSCrypto::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSCrypto* JSCrypto::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSCrypto* ptr = new (NotNull, JSC::allocateCell<JSCrypto>(vm)) JSCrypto(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Crypto__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSCrypto* JSCrypto::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSCrypto* ptr = new (NotNull, JSC::allocateCell<JSCrypto>(vm)) JSCrypto(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSCrypto* object = JSC::jsDynamicCast<JSCrypto*>(cell);
+extern "C" void* Crypto__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSCrypto* object = JSC::jsDynamicCast<JSCrypto*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Crypto__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSCrypto* object = JSC::jsDynamicCast<JSCrypto*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Crypto__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSCrypto* object = JSC::jsDynamicCast<JSCrypto*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Crypto__ptrOffset = JSCrypto::offsetOfWrapped();
 
 void JSCrypto::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -3691,7 +3970,7 @@ void JSCrypto::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSCrypto::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSCryptoConstructor::create(vm, globalObject, WebCore::JSCryptoConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSCryptoPrototype*>(prototype));
+  return WebCore::JSCryptoConstructor::create(vm, globalObject, WebCore::JSCryptoConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSCryptoPrototype*>(prototype));
 }
 
 JSObject* JSCrypto::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -3699,115 +3978,130 @@ JSObject* JSCrypto::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSCryptoPrototype::create(vm, globalObject, JSCryptoPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Crypto__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSCryptoStructure();
-    JSCrypto* instance = JSCrypto::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSCryptoHasherPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSCryptoHasherPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSCryptoHasherPrototype* ptr = new (NotNull, JSC::allocateCell<JSCryptoHasherPrototype>(vm)) JSCryptoHasherPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCryptoHasherPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSCryptoHasherPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue Crypto__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSCryptoStructure();
+  JSCrypto* instance = JSCrypto::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSCryptoHasherPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSCryptoHasherPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSCryptoHasherPrototype* ptr = new (NotNull, JSC::allocateCell<JSCryptoHasherPrototype>(vm)) JSCryptoHasherPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCryptoHasherPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSCryptoHasherPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSCryptoHasherConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSCryptoHasherConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSCryptoHasherPrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
+    public:
+        using Base = JSC::InternalFunction;
+        static JSCryptoHasherConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSCryptoHasherPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSCryptoHasherConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForCryptoHasherConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoHasherConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForCryptoHasherConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForCryptoHasherConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSCryptoHasherPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSCryptoHasherConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSCryptoHasherPrototype* prototype);
+    };
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSCryptoHasherConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForCryptoHasherConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoHasherConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForCryptoHasherConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForCryptoHasherConstructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSCryptoHasherPrototype* prototype);
+extern "C" void* CryptoHasherClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsCryptoHasherConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSCryptoHasherConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSCryptoHasherPrototype* prototype);
-};
 
-extern "C" void* CryptoHasherClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsCryptoHasherConstructor);
 
 extern "C" void CryptoHasherClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue CryptoHasherPrototype__getAlgorithm(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(CryptoHasherPrototype__algorithmGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue CryptoHasherPrototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(CryptoHasherPrototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue CryptoHasherPrototype__copy(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CryptoHasherPrototype__copyCallback);
 
+
 extern "C" EncodedJSValue CryptoHasherPrototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CryptoHasherPrototype__digestCallback);
 
+
 extern "C" EncodedJSValue CryptoHasherPrototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(CryptoHasherPrototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSCryptoHasherPrototype, JSCryptoHasherPrototype::Base);
 
-static const HashTableValue JSCryptoHasherPrototypeTableValues[] = {
-    { "algorithm"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CryptoHasherPrototype__algorithmGetterWrap, 0 } },
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CryptoHasherPrototype__byteLengthGetterWrap, 0 } },
-    { "copy"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoHasherPrototype__copyCallback, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoHasherPrototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoHasherPrototype__updateCallback, 2 } }
+
+  static const HashTableValue JSCryptoHasherPrototypeTableValues[] = {
+{ "algorithm"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CryptoHasherPrototype__algorithmGetterWrap, 0 } }  ,
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CryptoHasherPrototype__byteLengthGetterWrap, 0 } }  ,
+{ "copy"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoHasherPrototype__copyCallback, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoHasherPrototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoHasherPrototype__updateCallback, 2 } }
 };
 
+
+
 const ClassInfo JSCryptoHasherPrototype::s_info = { "CryptoHasher"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCryptoHasherPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsCryptoHasherConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -3818,43 +4112,49 @@ JSC_DEFINE_CUSTOM_GETTER(jsCryptoHasherConstructor, (JSGlobalObject * lexicalGlo
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for CryptoHasher"_s);
     return JSValue::encode(globalObject->JSCryptoHasherConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(CryptoHasherPrototype__algorithmGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSCryptoHasher* thisObject = jsCast<JSCryptoHasher*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_algorithm.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        CryptoHasherPrototype__getAlgorithm(thisObject->wrapped(), globalObject));
+        CryptoHasherPrototype__getAlgorithm(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_algorithm.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void CryptoHasherPrototype__algorithmSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSCryptoHasher*>(JSValue::decode(thisValue));
-    thisObject->m_algorithm.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue CryptoHasherPrototype__algorithmGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void CryptoHasherPrototype__algorithmSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSCryptoHasher*>(JSValue::decode(thisValue));
+      thisObject->m_algorithm.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue CryptoHasherPrototype__algorithmGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSCryptoHasher*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_algorithm.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(CryptoHasherPrototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSCryptoHasher* thisObject = jsCast<JSCryptoHasher*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -3862,90 +4162,94 @@ JSC_DEFINE_CUSTOM_GETTER(CryptoHasherPrototype__byteLengthGetterWrap, (JSGlobalO
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(CryptoHasherPrototype__copyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(CryptoHasherPrototype__copyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSCryptoHasher* thisObject = jsDynamicCast<JSCryptoHasher*>(callFrame->thisValue());
+        JSCryptoHasher* thisObject = jsDynamicCast<JSCryptoHasher*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof CryptoHasher"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof CryptoHasher"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return CryptoHasherPrototype__copy(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return CryptoHasherPrototype__copy(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(CryptoHasherPrototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(CryptoHasherPrototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSCryptoHasher* thisObject = jsDynamicCast<JSCryptoHasher*>(callFrame->thisValue());
 
-    JSCryptoHasher* thisObject = jsDynamicCast<JSCryptoHasher*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof CryptoHasher"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof CryptoHasher"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CryptoHasherPrototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return CryptoHasherPrototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(CryptoHasherPrototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(CryptoHasherPrototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSCryptoHasher* thisObject = jsDynamicCast<JSCryptoHasher*>(callFrame->thisValue());
 
-    JSCryptoHasher* thisObject = jsDynamicCast<JSCryptoHasher*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof CryptoHasher"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof CryptoHasher"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return CryptoHasherPrototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return CryptoHasherPrototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSCryptoHasherPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -3957,11 +4261,12 @@ void JSCryptoHasherPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* g
 extern "C" JSC_DECLARE_CUSTOM_GETTER(CryptoHasherClass__getAlgorithms);
 extern "C" JSC_DECLARE_HOST_FUNCTION(CryptoHasherClass__hash);
 
-static const HashTableValue JSCryptoHasherConstructorTableValues[] = {
-    { "algorithms"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CryptoHasherClass__getAlgorithms, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoHasherClass__hash, 2 } }
+  static const HashTableValue JSCryptoHasherConstructorTableValues[] = {
+{ "algorithms"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, CryptoHasherClass__getAlgorithms, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, CryptoHasherClass__hash, 2 } }
 };
 
+
 void JSCryptoHasherConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSCryptoHasherPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "CryptoHasher"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -3970,59 +4275,62 @@ void JSCryptoHasherConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* glob
     ASSERT(inherits(info()));
 }
 
-JSCryptoHasherConstructor::JSCryptoHasherConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSCryptoHasherConstructor::JSCryptoHasherConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSCryptoHasherConstructor* JSCryptoHasherConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSCryptoHasherPrototype* prototype)
-{
+  }
+
+JSCryptoHasherConstructor* JSCryptoHasherConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSCryptoHasherPrototype* prototype) {
     JSCryptoHasherConstructor* ptr = new (NotNull, JSC::allocateCell<JSCryptoHasherConstructor>(vm)) JSCryptoHasherConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSCryptoHasherConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSCryptoHasherConstructor();
     Structure* structure = globalObject->JSCryptoHasherStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSCryptoHasherStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSCryptoHasherStructure()
+      );
     }
 
     void* ptr = CryptoHasherClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSCryptoHasher* instance = JSCryptoHasher::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSCryptoHasherConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSCryptoHasherPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSCryptoHasherConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCryptoHasherConstructor) };
 
-extern "C" EncodedJSValue CryptoHasher__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue CryptoHasher__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSCryptoHasherConstructor());
-}
+  }
 
 JSCryptoHasher::~JSCryptoHasher()
 {
@@ -4034,7 +4342,7 @@ void JSCryptoHasher::destroy(JSCell* cell)
 {
     static_cast<JSCryptoHasher*>(cell)->JSCryptoHasher::~JSCryptoHasher();
 }
-
+  
 const ClassInfo JSCryptoHasher::s_info = { "CryptoHasher"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSCryptoHasher) };
 
 void JSCryptoHasher::finishCreation(VM& vm)
@@ -4043,38 +4351,37 @@ void JSCryptoHasher::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSCryptoHasher* JSCryptoHasher::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSCryptoHasher* ptr = new (NotNull, JSC::allocateCell<JSCryptoHasher>(vm)) JSCryptoHasher(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* CryptoHasher__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSCryptoHasher* JSCryptoHasher::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSCryptoHasher* ptr = new (NotNull, JSC::allocateCell<JSCryptoHasher>(vm)) JSCryptoHasher(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSCryptoHasher* object = JSC::jsDynamicCast<JSCryptoHasher*>(cell);
+extern "C" void* CryptoHasher__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSCryptoHasher* object = JSC::jsDynamicCast<JSCryptoHasher*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool CryptoHasher__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSCryptoHasher* object = JSC::jsDynamicCast<JSCryptoHasher*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool CryptoHasher__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSCryptoHasher* object = JSC::jsDynamicCast<JSCryptoHasher*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t CryptoHasher__ptrOffset = JSCryptoHasher::offsetOfWrapped();
 
 void JSCryptoHasher::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -4089,7 +4396,7 @@ void JSCryptoHasher::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSCryptoHasher::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSCryptoHasherConstructor::create(vm, globalObject, WebCore::JSCryptoHasherConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSCryptoHasherPrototype*>(prototype));
+  return WebCore::JSCryptoHasherConstructor::create(vm, globalObject, WebCore::JSCryptoHasherConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSCryptoHasherPrototype*>(prototype));
 }
 
 JSObject* JSCryptoHasher::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -4097,13 +4404,12 @@ JSObject* JSCryptoHasher::createPrototype(VM& vm, JSDOMGlobalObject* globalObjec
     return JSCryptoHasherPrototype::create(vm, globalObject, JSCryptoHasherPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue CryptoHasher__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSCryptoHasherStructure();
-    JSCryptoHasher* instance = JSCryptoHasher::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue CryptoHasher__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSCryptoHasherStructure();
+  JSCryptoHasher* instance = JSCryptoHasher::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -4112,7 +4418,7 @@ void JSCryptoHasher::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSCryptoHasher* thisObject = jsCast<JSCryptoHasher*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -4121,17 +4427,18 @@ DEFINE_VISIT_CHILDREN(JSCryptoHasher);
 template<typename Visitor>
 void JSCryptoHasher::visitAdditionalChildren(Visitor& visitor)
 {
-    JSCryptoHasher* thisObject = this;
+  JSCryptoHasher* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_algorithms);
+    
+        visitor.append(thisObject->m_algorithms);
     visitor.append(thisObject->m_algorithm);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSCryptoHasher);
 
 template<typename Visitor>
-void JSCryptoHasher::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSCryptoHasher::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSCryptoHasher* thisObject = jsCast<JSCryptoHasher*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -4139,106 +4446,130 @@ void JSCryptoHasher::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSCryptoHasher);
-class JSDebugHTTPSServerPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSDebugHTTPSServerPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSDebugHTTPSServerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSDebugHTTPSServerPrototype* ptr = new (NotNull, JSC::allocateCell<JSDebugHTTPSServerPrototype>(vm)) JSDebugHTTPSServerPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDebugHTTPSServerPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSDebugHTTPSServerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSDebugHTTPSServerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSDebugHTTPSServerPrototype* ptr = new (NotNull, JSC::allocateCell<JSDebugHTTPSServerPrototype>(vm)) JSDebugHTTPSServerPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* DebugHTTPSServerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsDebugHTTPSServerConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDebugHTTPSServerPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSDebugHTTPSServerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* DebugHTTPSServerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsDebugHTTPSServerConstructor);
 
 extern "C" void DebugHTTPSServerClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPSServerPrototype__getAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPSServerPrototype__addressGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPSServerPrototype__getDevelopment(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPSServerPrototype__developmentGetterWrap);
 
+
 extern "C" EncodedJSValue DebugHTTPSServerPrototype__doFetch(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPSServerPrototype__fetchCallback);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPSServerPrototype__getHostname(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPSServerPrototype__hostnameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPSServerPrototype__getId(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPSServerPrototype__idGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPSServerPrototype__getPendingRequests(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPSServerPrototype__pendingRequestsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPSServerPrototype__getPendingWebSockets(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPSServerPrototype__pendingWebSocketsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPSServerPrototype__getPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPSServerPrototype__portGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPSServerPrototype__getProtocol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPSServerPrototype__protocolGetterWrap);
 
+
 extern "C" EncodedJSValue DebugHTTPSServerPrototype__doPublish(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPSServerPrototype__publishCallback);
 
+
 extern "C" EncodedJSValue DebugHTTPSServerPrototype__doReload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPSServerPrototype__reloadCallback);
 
+
 extern "C" EncodedJSValue DebugHTTPSServerPrototype__doRequestIP(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPSServerPrototype__requestIPCallback);
 
+
 extern "C" EncodedJSValue DebugHTTPSServerPrototype__doStop(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPSServerPrototype__stopCallback);
 
+
 extern "C" EncodedJSValue DebugHTTPSServerPrototype__doUpgrade(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPSServerPrototype__upgradeCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDebugHTTPSServerPrototype, JSDebugHTTPSServerPrototype::Base);
 
-static const HashTableValue JSDebugHTTPSServerPrototypeTableValues[] = {
-    { "address"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__addressGetterWrap, 0 } },
-    { "development"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__developmentGetterWrap, 0 } },
-    { "fetch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__fetchCallback, 1 } },
-    { "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__hostnameGetterWrap, 0 } },
-    { "id"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__idGetterWrap, 0 } },
-    { "pendingRequests"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__pendingRequestsGetterWrap, 0 } },
-    { "pendingWebSockets"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__pendingWebSocketsGetterWrap, 0 } },
-    { "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__portGetterWrap, 0 } },
-    { "protocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__protocolGetterWrap, 0 } },
-    { "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__publishCallback, 3 } },
-    { "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__reloadCallback, 2 } },
-    { "requestIP"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__requestIPCallback, 1 } },
-    { "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__stopCallback, 1 } },
-    { "upgrade"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__upgradeCallback, 1 } }
+
+  static const HashTableValue JSDebugHTTPSServerPrototypeTableValues[] = {
+{ "address"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__addressGetterWrap, 0 } }  ,
+{ "development"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__developmentGetterWrap, 0 } }  ,
+{ "fetch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__fetchCallback, 1 } }  ,
+{ "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__hostnameGetterWrap, 0 } }  ,
+{ "id"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__idGetterWrap, 0 } }  ,
+{ "pendingRequests"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__pendingRequestsGetterWrap, 0 } }  ,
+{ "pendingWebSockets"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__pendingWebSocketsGetterWrap, 0 } }  ,
+{ "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__portGetterWrap, 0 } }  ,
+{ "protocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPSServerPrototype__protocolGetterWrap, 0 } }  ,
+{ "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__publishCallback, 3 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__reloadCallback, 2 } }  ,
+{ "requestIP"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__requestIPCallback, 1 } }  ,
+{ "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__stopCallback, 1 } }  ,
+{ "upgrade"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPSServerPrototype__upgradeCallback, 1 } }
 };
 
+
+
 const ClassInfo JSDebugHTTPSServerPrototype::s_info = { "DebugHTTPSServer"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDebugHTTPSServerPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsDebugHTTPSServerConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -4249,43 +4580,49 @@ JSC_DEFINE_CUSTOM_GETTER(jsDebugHTTPSServerConstructor, (JSGlobalObject * lexica
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for DebugHTTPSServer"_s);
     return JSValue::encode(globalObject->JSDebugHTTPSServerConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__addressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_address.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DebugHTTPSServerPrototype__getAddress(thisObject->wrapped(), globalObject));
+        DebugHTTPSServerPrototype__getAddress(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_address.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DebugHTTPSServerPrototype__addressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
-    thisObject->m_address.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DebugHTTPSServerPrototype__addressGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DebugHTTPSServerPrototype__addressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
+      thisObject->m_address.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DebugHTTPSServerPrototype__addressGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_address.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__developmentGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4293,101 +4630,111 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__developmentGetterWrap, (JSGl
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__fetchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__fetchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
+        JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return DebugHTTPSServerPrototype__doFetch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return DebugHTTPSServerPrototype__doFetch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__hostnameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_hostname.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DebugHTTPSServerPrototype__getHostname(thisObject->wrapped(), globalObject));
+        DebugHTTPSServerPrototype__getHostname(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_hostname.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DebugHTTPSServerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
-    thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DebugHTTPSServerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DebugHTTPSServerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
+      thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DebugHTTPSServerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_hostname.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__idGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_id.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DebugHTTPSServerPrototype__getId(thisObject->wrapped(), globalObject));
+        DebugHTTPSServerPrototype__getId(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_id.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DebugHTTPSServerPrototype__idSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
-    thisObject->m_id.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DebugHTTPSServerPrototype__idGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DebugHTTPSServerPrototype__idSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
+      thisObject->m_id.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DebugHTTPSServerPrototype__idGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_id.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__pendingRequestsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4395,11 +4742,12 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__pendingRequestsGetterWrap, (
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__pendingWebSocketsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4407,11 +4755,12 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__pendingWebSocketsGetterWrap,
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__portGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4419,11 +4768,12 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__portGetterWrap, (JSGlobalObj
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__protocolGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4431,146 +4781,152 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPSServerPrototype__protocolGetterWrap, (JSGloba
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
+        JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return DebugHTTPSServerPrototype__doPublish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DebugHTTPSServerPrototype__doPublish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
 
-    JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPSServerPrototype__doReload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DebugHTTPSServerPrototype__doReload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__requestIPCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__requestIPCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
 
-    JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPSServerPrototype__doRequestIP(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DebugHTTPSServerPrototype__doRequestIP(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
 
-    JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPSServerPrototype__doStop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DebugHTTPSServerPrototype__doStop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__upgradeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPSServerPrototype__upgradeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
 
-    JSDebugHTTPSServer* thisObject = jsDynamicCast<JSDebugHTTPSServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPSServerPrototype__doUpgrade(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return DebugHTTPSServerPrototype__doUpgrade(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSDebugHTTPSServerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -4589,7 +4945,7 @@ void JSDebugHTTPSServer::destroy(JSCell* cell)
 {
     static_cast<JSDebugHTTPSServer*>(cell)->JSDebugHTTPSServer::~JSDebugHTTPSServer();
 }
-
+  
 const ClassInfo JSDebugHTTPSServer::s_info = { "DebugHTTPSServer"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDebugHTTPSServer) };
 
 void JSDebugHTTPSServer::finishCreation(VM& vm)
@@ -4598,38 +4954,37 @@ void JSDebugHTTPSServer::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSDebugHTTPSServer* JSDebugHTTPSServer::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSDebugHTTPSServer* ptr = new (NotNull, JSC::allocateCell<JSDebugHTTPSServer>(vm)) JSDebugHTTPSServer(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* DebugHTTPSServer__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSDebugHTTPSServer* JSDebugHTTPSServer::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSDebugHTTPSServer* ptr = new (NotNull, JSC::allocateCell<JSDebugHTTPSServer>(vm)) JSDebugHTTPSServer(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSDebugHTTPSServer* object = JSC::jsDynamicCast<JSDebugHTTPSServer*>(cell);
+extern "C" void* DebugHTTPSServer__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSDebugHTTPSServer* object = JSC::jsDynamicCast<JSDebugHTTPSServer*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool DebugHTTPSServer__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSDebugHTTPSServer* object = JSC::jsDynamicCast<JSDebugHTTPSServer*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool DebugHTTPSServer__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSDebugHTTPSServer* object = JSC::jsDynamicCast<JSDebugHTTPSServer*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t DebugHTTPSServer__ptrOffset = JSDebugHTTPSServer::offsetOfWrapped();
 
 void JSDebugHTTPSServer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -4642,18 +4997,19 @@ void JSDebugHTTPSServer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSDebugHTTPSServer::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSDebugHTTPSServerPrototype::create(vm, globalObject, JSDebugHTTPSServerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue DebugHTTPSServer__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSDebugHTTPSServerStructure();
-    JSDebugHTTPSServer* instance = JSDebugHTTPSServer::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue DebugHTTPSServer__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSDebugHTTPSServerStructure();
+  JSDebugHTTPSServer* instance = JSDebugHTTPSServer::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -4662,7 +5018,7 @@ void JSDebugHTTPSServer::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -4671,18 +5027,19 @@ DEFINE_VISIT_CHILDREN(JSDebugHTTPSServer);
 template<typename Visitor>
 void JSDebugHTTPSServer::visitAdditionalChildren(Visitor& visitor)
 {
-    JSDebugHTTPSServer* thisObject = this;
+  JSDebugHTTPSServer* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_address);
+    
+        visitor.append(thisObject->m_address);
     visitor.append(thisObject->m_hostname);
     visitor.append(thisObject->m_id);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSDebugHTTPSServer);
 
 template<typename Visitor>
-void JSDebugHTTPSServer::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSDebugHTTPSServer::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSDebugHTTPSServer* thisObject = jsCast<JSDebugHTTPSServer*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -4690,106 +5047,130 @@ void JSDebugHTTPSServer::visitOutputConstraintsImpl(JSCell* cell, Visitor& visit
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSDebugHTTPSServer);
-class JSDebugHTTPServerPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSDebugHTTPServerPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSDebugHTTPServerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSDebugHTTPServerPrototype* ptr = new (NotNull, JSC::allocateCell<JSDebugHTTPServerPrototype>(vm)) JSDebugHTTPServerPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDebugHTTPServerPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSDebugHTTPServerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSDebugHTTPServerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSDebugHTTPServerPrototype* ptr = new (NotNull, JSC::allocateCell<JSDebugHTTPServerPrototype>(vm)) JSDebugHTTPServerPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* DebugHTTPServerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsDebugHTTPServerConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDebugHTTPServerPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSDebugHTTPServerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* DebugHTTPServerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsDebugHTTPServerConstructor);
 
 extern "C" void DebugHTTPServerClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPServerPrototype__getAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPServerPrototype__addressGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPServerPrototype__getDevelopment(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPServerPrototype__developmentGetterWrap);
 
+
 extern "C" EncodedJSValue DebugHTTPServerPrototype__doFetch(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPServerPrototype__fetchCallback);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPServerPrototype__getHostname(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPServerPrototype__hostnameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPServerPrototype__getId(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPServerPrototype__idGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPServerPrototype__getPendingRequests(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPServerPrototype__pendingRequestsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPServerPrototype__getPendingWebSockets(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPServerPrototype__pendingWebSocketsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPServerPrototype__getPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPServerPrototype__portGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DebugHTTPServerPrototype__getProtocol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DebugHTTPServerPrototype__protocolGetterWrap);
 
+
 extern "C" EncodedJSValue DebugHTTPServerPrototype__doPublish(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPServerPrototype__publishCallback);
 
+
 extern "C" EncodedJSValue DebugHTTPServerPrototype__doReload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPServerPrototype__reloadCallback);
 
+
 extern "C" EncodedJSValue DebugHTTPServerPrototype__doRequestIP(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPServerPrototype__requestIPCallback);
 
+
 extern "C" EncodedJSValue DebugHTTPServerPrototype__doStop(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPServerPrototype__stopCallback);
 
+
 extern "C" EncodedJSValue DebugHTTPServerPrototype__doUpgrade(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DebugHTTPServerPrototype__upgradeCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDebugHTTPServerPrototype, JSDebugHTTPServerPrototype::Base);
 
-static const HashTableValue JSDebugHTTPServerPrototypeTableValues[] = {
-    { "address"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__addressGetterWrap, 0 } },
-    { "development"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__developmentGetterWrap, 0 } },
-    { "fetch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__fetchCallback, 1 } },
-    { "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__hostnameGetterWrap, 0 } },
-    { "id"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__idGetterWrap, 0 } },
-    { "pendingRequests"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__pendingRequestsGetterWrap, 0 } },
-    { "pendingWebSockets"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__pendingWebSocketsGetterWrap, 0 } },
-    { "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__portGetterWrap, 0 } },
-    { "protocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__protocolGetterWrap, 0 } },
-    { "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__publishCallback, 3 } },
-    { "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__reloadCallback, 2 } },
-    { "requestIP"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__requestIPCallback, 1 } },
-    { "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__stopCallback, 1 } },
-    { "upgrade"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__upgradeCallback, 1 } }
+
+  static const HashTableValue JSDebugHTTPServerPrototypeTableValues[] = {
+{ "address"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__addressGetterWrap, 0 } }  ,
+{ "development"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__developmentGetterWrap, 0 } }  ,
+{ "fetch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__fetchCallback, 1 } }  ,
+{ "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__hostnameGetterWrap, 0 } }  ,
+{ "id"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__idGetterWrap, 0 } }  ,
+{ "pendingRequests"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__pendingRequestsGetterWrap, 0 } }  ,
+{ "pendingWebSockets"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__pendingWebSocketsGetterWrap, 0 } }  ,
+{ "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__portGetterWrap, 0 } }  ,
+{ "protocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DebugHTTPServerPrototype__protocolGetterWrap, 0 } }  ,
+{ "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__publishCallback, 3 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__reloadCallback, 2 } }  ,
+{ "requestIP"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__requestIPCallback, 1 } }  ,
+{ "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__stopCallback, 1 } }  ,
+{ "upgrade"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DebugHTTPServerPrototype__upgradeCallback, 1 } }
 };
 
+
+
 const ClassInfo JSDebugHTTPServerPrototype::s_info = { "DebugHTTPServer"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDebugHTTPServerPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsDebugHTTPServerConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -4800,43 +5181,49 @@ JSC_DEFINE_CUSTOM_GETTER(jsDebugHTTPServerConstructor, (JSGlobalObject * lexical
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for DebugHTTPServer"_s);
     return JSValue::encode(globalObject->JSDebugHTTPServerConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__addressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_address.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DebugHTTPServerPrototype__getAddress(thisObject->wrapped(), globalObject));
+        DebugHTTPServerPrototype__getAddress(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_address.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DebugHTTPServerPrototype__addressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
-    thisObject->m_address.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DebugHTTPServerPrototype__addressGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DebugHTTPServerPrototype__addressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
+      thisObject->m_address.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DebugHTTPServerPrototype__addressGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_address.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__developmentGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4844,101 +5231,111 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__developmentGetterWrap, (JSGlo
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__fetchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__fetchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
+        JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return DebugHTTPServerPrototype__doFetch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return DebugHTTPServerPrototype__doFetch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__hostnameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_hostname.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DebugHTTPServerPrototype__getHostname(thisObject->wrapped(), globalObject));
+        DebugHTTPServerPrototype__getHostname(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_hostname.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DebugHTTPServerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
-    thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DebugHTTPServerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DebugHTTPServerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
+      thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DebugHTTPServerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_hostname.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__idGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_id.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DebugHTTPServerPrototype__getId(thisObject->wrapped(), globalObject));
+        DebugHTTPServerPrototype__getId(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_id.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DebugHTTPServerPrototype__idSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
-    thisObject->m_id.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DebugHTTPServerPrototype__idGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DebugHTTPServerPrototype__idSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
+      thisObject->m_id.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DebugHTTPServerPrototype__idGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_id.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__pendingRequestsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4946,11 +5343,12 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__pendingRequestsGetterWrap, (J
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__pendingWebSocketsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4958,11 +5356,12 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__pendingWebSocketsGetterWrap,
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__portGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4970,11 +5369,12 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__portGetterWrap, (JSGlobalObje
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__protocolGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -4982,146 +5382,152 @@ JSC_DEFINE_CUSTOM_GETTER(DebugHTTPServerPrototype__protocolGetterWrap, (JSGlobal
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
+        JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPServerPrototype__doPublish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DebugHTTPServerPrototype__doPublish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
 
-    JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPServerPrototype__doReload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DebugHTTPServerPrototype__doReload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__requestIPCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__requestIPCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
 
-    JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPServerPrototype__doRequestIP(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DebugHTTPServerPrototype__doRequestIP(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
 
-    JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPServerPrototype__doStop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DebugHTTPServerPrototype__doStop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__upgradeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DebugHTTPServerPrototype__upgradeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
 
-    JSDebugHTTPServer* thisObject = jsDynamicCast<JSDebugHTTPServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DebugHTTPServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DebugHTTPServerPrototype__doUpgrade(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return DebugHTTPServerPrototype__doUpgrade(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSDebugHTTPServerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -5140,7 +5546,7 @@ void JSDebugHTTPServer::destroy(JSCell* cell)
 {
     static_cast<JSDebugHTTPServer*>(cell)->JSDebugHTTPServer::~JSDebugHTTPServer();
 }
-
+  
 const ClassInfo JSDebugHTTPServer::s_info = { "DebugHTTPServer"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDebugHTTPServer) };
 
 void JSDebugHTTPServer::finishCreation(VM& vm)
@@ -5149,38 +5555,37 @@ void JSDebugHTTPServer::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSDebugHTTPServer* JSDebugHTTPServer::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSDebugHTTPServer* ptr = new (NotNull, JSC::allocateCell<JSDebugHTTPServer>(vm)) JSDebugHTTPServer(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* DebugHTTPServer__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSDebugHTTPServer* JSDebugHTTPServer::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSDebugHTTPServer* ptr = new (NotNull, JSC::allocateCell<JSDebugHTTPServer>(vm)) JSDebugHTTPServer(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSDebugHTTPServer* object = JSC::jsDynamicCast<JSDebugHTTPServer*>(cell);
+extern "C" void* DebugHTTPServer__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSDebugHTTPServer* object = JSC::jsDynamicCast<JSDebugHTTPServer*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool DebugHTTPServer__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSDebugHTTPServer* object = JSC::jsDynamicCast<JSDebugHTTPServer*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool DebugHTTPServer__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSDebugHTTPServer* object = JSC::jsDynamicCast<JSDebugHTTPServer*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t DebugHTTPServer__ptrOffset = JSDebugHTTPServer::offsetOfWrapped();
 
 void JSDebugHTTPServer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -5193,18 +5598,19 @@ void JSDebugHTTPServer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSDebugHTTPServer::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSDebugHTTPServerPrototype::create(vm, globalObject, JSDebugHTTPServerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue DebugHTTPServer__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSDebugHTTPServerStructure();
-    JSDebugHTTPServer* instance = JSDebugHTTPServer::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue DebugHTTPServer__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSDebugHTTPServerStructure();
+  JSDebugHTTPServer* instance = JSDebugHTTPServer::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -5213,7 +5619,7 @@ void JSDebugHTTPServer::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -5222,18 +5628,19 @@ DEFINE_VISIT_CHILDREN(JSDebugHTTPServer);
 template<typename Visitor>
 void JSDebugHTTPServer::visitAdditionalChildren(Visitor& visitor)
 {
-    JSDebugHTTPServer* thisObject = this;
+  JSDebugHTTPServer* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_address);
+    
+        visitor.append(thisObject->m_address);
     visitor.append(thisObject->m_hostname);
     visitor.append(thisObject->m_id);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSDebugHTTPServer);
 
 template<typename Visitor>
-void JSDebugHTTPServer::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSDebugHTTPServer::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSDebugHTTPServer* thisObject = jsCast<JSDebugHTTPServer*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -5241,119 +5648,138 @@ void JSDebugHTTPServer::visitOutputConstraintsImpl(JSCell* cell, Visitor& visito
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSDebugHTTPServer);
-class JSDirentPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSDirentPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSDirentPrototype* ptr = new (NotNull, JSC::allocateCell<JSDirentPrototype>(vm)) JSDirentPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDirentPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSDirentPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSDirentPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSDirentPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSDirentPrototype* ptr = new (NotNull, JSC::allocateCell<JSDirentPrototype>(vm)) JSDirentPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDirentPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSDirentPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSDirentConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSDirentConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSDirentPrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
+    public:
+        using Base = JSC::InternalFunction;
+        static JSDirentConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSDirentPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSDirentConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForDirentConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDirentConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForDirentConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForDirentConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSDirentPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSDirentConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSDirentPrototype* prototype);
+    };
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSDirentConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForDirentConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDirentConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForDirentConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForDirentConstructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSDirentPrototype* prototype);
+extern "C" void* DirentClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsDirentConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSDirentConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSDirentPrototype* prototype);
-};
 
-extern "C" void* DirentClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsDirentConstructor);
 
 extern "C" void DirentClass__finalize(void*);
 
+
 extern "C" EncodedJSValue DirentPrototype__isBlockDevice(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DirentPrototype__isBlockDeviceCallback);
 
+
 extern "C" EncodedJSValue DirentPrototype__isCharacterDevice(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DirentPrototype__isCharacterDeviceCallback);
 
+
 extern "C" EncodedJSValue DirentPrototype__isDirectory(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DirentPrototype__isDirectoryCallback);
 
+
 extern "C" EncodedJSValue DirentPrototype__isFIFO(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DirentPrototype__isFIFOCallback);
 
+
 extern "C" EncodedJSValue DirentPrototype__isFile(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DirentPrototype__isFileCallback);
 
+
 extern "C" EncodedJSValue DirentPrototype__isSocket(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DirentPrototype__isSocketCallback);
 
+
 extern "C" EncodedJSValue DirentPrototype__isSymbolicLink(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DirentPrototype__isSymbolicLinkCallback);
 
+
 extern "C" JSC::EncodedJSValue DirentPrototype__getName(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DirentPrototype__nameGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDirentPrototype, JSDirentPrototype::Base);
 
-static const HashTableValue JSDirentPrototypeTableValues[] = {
-    { "isBlockDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isBlockDeviceCallback, 0 } },
-    { "isCharacterDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isCharacterDeviceCallback, 0 } },
-    { "isDirectory"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isDirectoryCallback, 0 } },
-    { "isFIFO"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isFIFOCallback, 0 } },
-    { "isFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isFileCallback, 0 } },
-    { "isSocket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isSocketCallback, 0 } },
-    { "isSymbolicLink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isSymbolicLinkCallback, 0 } },
-    { "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DirentPrototype__nameGetterWrap, 0 } }
+
+  static const HashTableValue JSDirentPrototypeTableValues[] = {
+{ "isBlockDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isBlockDeviceCallback, 0 } }  ,
+{ "isCharacterDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isCharacterDeviceCallback, 0 } }  ,
+{ "isDirectory"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isDirectoryCallback, 0 } }  ,
+{ "isFIFO"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isFIFOCallback, 0 } }  ,
+{ "isFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isFileCallback, 0 } }  ,
+{ "isSocket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isSocketCallback, 0 } }  ,
+{ "isSymbolicLink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DirentPrototype__isSymbolicLinkCallback, 0 } }  ,
+{ "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DirentPrototype__nameGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSDirentPrototype::s_info = { "Dirent"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDirentPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsDirentConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -5364,234 +5790,247 @@ JSC_DEFINE_CUSTOM_GETTER(jsDirentConstructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Dirent"_s);
     return JSValue::encode(globalObject->JSDirentConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isBlockDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isBlockDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return DirentPrototype__isBlockDevice(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DirentPrototype__isBlockDevice(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isCharacterDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isCharacterDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
 
-    JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DirentPrototype__isCharacterDevice(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DirentPrototype__isCharacterDevice(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isDirectoryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isDirectoryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
 
-    JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DirentPrototype__isDirectory(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DirentPrototype__isDirectory(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isFIFOCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isFIFOCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
 
-    JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DirentPrototype__isFIFO(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DirentPrototype__isFIFO(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
 
-    JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DirentPrototype__isFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DirentPrototype__isFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isSocketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isSocketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
 
-    JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DirentPrototype__isSocket(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return DirentPrototype__isSocket(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isSymbolicLinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(DirentPrototype__isSymbolicLinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
 
-    JSDirent* thisObject = jsDynamicCast<JSDirent*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Dirent"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return DirentPrototype__isSymbolicLink(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return DirentPrototype__isSymbolicLink(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(DirentPrototype__nameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDirent* thisObject = jsCast<JSDirent*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_name.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DirentPrototype__getName(thisObject->wrapped(), globalObject));
+        DirentPrototype__getName(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_name.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DirentPrototype__nameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDirent*>(JSValue::decode(thisValue));
-    thisObject->m_name.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DirentPrototype__nameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DirentPrototype__nameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDirent*>(JSValue::decode(thisValue));
+      thisObject->m_name.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DirentPrototype__nameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDirent*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_name.get());
-}
+  }
+  
+  
 
 void JSDirentPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -5603,64 +6042,67 @@ void JSDirentPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalO
 void JSDirentConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSDirentPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "Dirent"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSDirentConstructor::JSDirentConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSDirentConstructor::JSDirentConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSDirentConstructor* JSDirentConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSDirentPrototype* prototype)
-{
+  }
+
+JSDirentConstructor* JSDirentConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSDirentPrototype* prototype) {
     JSDirentConstructor* ptr = new (NotNull, JSC::allocateCell<JSDirentConstructor>(vm)) JSDirentConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSDirentConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSDirentConstructor();
     Structure* structure = globalObject->JSDirentStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSDirentStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSDirentStructure()
+      );
     }
 
     void* ptr = DirentClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSDirent* instance = JSDirent::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSDirentConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSDirentPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSDirentConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDirentConstructor) };
 
-extern "C" EncodedJSValue Dirent__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue Dirent__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSDirentConstructor());
-}
+  }
 
 JSDirent::~JSDirent()
 {
@@ -5672,7 +6114,7 @@ void JSDirent::destroy(JSCell* cell)
 {
     static_cast<JSDirent*>(cell)->JSDirent::~JSDirent();
 }
-
+  
 const ClassInfo JSDirent::s_info = { "Dirent"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDirent) };
 
 void JSDirent::finishCreation(VM& vm)
@@ -5681,38 +6123,37 @@ void JSDirent::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSDirent* JSDirent::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSDirent* ptr = new (NotNull, JSC::allocateCell<JSDirent>(vm)) JSDirent(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Dirent__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSDirent* JSDirent::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSDirent* ptr = new (NotNull, JSC::allocateCell<JSDirent>(vm)) JSDirent(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSDirent* object = JSC::jsDynamicCast<JSDirent*>(cell);
+extern "C" void* Dirent__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSDirent* object = JSC::jsDynamicCast<JSDirent*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Dirent__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSDirent* object = JSC::jsDynamicCast<JSDirent*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Dirent__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSDirent* object = JSC::jsDynamicCast<JSDirent*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Dirent__ptrOffset = JSDirent::offsetOfWrapped();
 
 void JSDirent::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -5727,7 +6168,7 @@ void JSDirent::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSDirent::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSDirentConstructor::create(vm, globalObject, WebCore::JSDirentConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSDirentPrototype*>(prototype));
+  return WebCore::JSDirentConstructor::create(vm, globalObject, WebCore::JSDirentConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSDirentPrototype*>(prototype));
 }
 
 JSObject* JSDirent::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -5735,13 +6176,12 @@ JSObject* JSDirent::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSDirentPrototype::create(vm, globalObject, JSDirentPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Dirent__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSDirentStructure();
-    JSDirent* instance = JSDirent::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Dirent__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSDirentStructure();
+  JSDirent* instance = JSDirent::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -5750,7 +6190,7 @@ void JSDirent::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSDirent* thisObject = jsCast<JSDirent*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -5759,16 +6199,17 @@ DEFINE_VISIT_CHILDREN(JSDirent);
 template<typename Visitor>
 void JSDirent::visitAdditionalChildren(Visitor& visitor)
 {
-    JSDirent* thisObject = this;
+  JSDirent* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_name);
+    
+        visitor.append(thisObject->m_name);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSDirent);
 
 template<typename Visitor>
-void JSDirent::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSDirent::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSDirent* thisObject = jsCast<JSDirent*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -5776,54 +6217,65 @@ void JSDirent::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSDirent);
-class JSDocEndPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSDocEndPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSDocEndPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSDocEndPrototype* ptr = new (NotNull, JSC::allocateCell<JSDocEndPrototype>(vm)) JSDocEndPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDocEndPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSDocEndPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSDocEndPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSDocEndPrototype* ptr = new (NotNull, JSC::allocateCell<JSDocEndPrototype>(vm)) JSDocEndPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* DocEndClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsDocEndConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDocEndPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSDocEndPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* DocEndClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsDocEndConstructor);
 
 extern "C" void DocEndClass__finalize(void*);
 
+
 extern "C" EncodedJSValue DocEndPrototype__append(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(DocEndPrototype__appendCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDocEndPrototype, JSDocEndPrototype::Base);
 
-static const HashTableValue JSDocEndPrototypeTableValues[] = {
-    { "append"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DocEndPrototype__appendCallback, 1 } }
+
+  static const HashTableValue JSDocEndPrototypeTableValues[] = {
+{ "append"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, DocEndPrototype__appendCallback, 1 } }
 };
 
+
+
 const ClassInfo JSDocEndPrototype::s_info = { "DocEnd"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDocEndPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsDocEndConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -5834,35 +6286,38 @@ JSC_DEFINE_CUSTOM_GETTER(jsDocEndConstructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for DocEnd"_s);
     return JSValue::encode(globalObject->JSDocEndConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(DocEndPrototype__appendCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSDocEnd* thisObject = jsDynamicCast<JSDocEnd*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(DocEndPrototype__appendCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DocEnd"_s);
-        return JSValue::encode({});
-    }
+        JSDocEnd* thisObject = jsDynamicCast<JSDocEnd*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof DocEnd"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    return DocEndPrototype__append(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return DocEndPrototype__append(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 void JSDocEndPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -5881,7 +6336,7 @@ void JSDocEnd::destroy(JSCell* cell)
 {
     static_cast<JSDocEnd*>(cell)->JSDocEnd::~JSDocEnd();
 }
-
+  
 const ClassInfo JSDocEnd::s_info = { "DocEnd"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDocEnd) };
 
 void JSDocEnd::finishCreation(VM& vm)
@@ -5890,38 +6345,37 @@ void JSDocEnd::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSDocEnd* JSDocEnd::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSDocEnd* ptr = new (NotNull, JSC::allocateCell<JSDocEnd>(vm)) JSDocEnd(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* DocEnd__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSDocEnd* JSDocEnd::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSDocEnd* ptr = new (NotNull, JSC::allocateCell<JSDocEnd>(vm)) JSDocEnd(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSDocEnd* object = JSC::jsDynamicCast<JSDocEnd*>(cell);
+extern "C" void* DocEnd__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSDocEnd* object = JSC::jsDynamicCast<JSDocEnd*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool DocEnd__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSDocEnd* object = JSC::jsDynamicCast<JSDocEnd*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool DocEnd__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSDocEnd* object = JSC::jsDynamicCast<JSDocEnd*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t DocEnd__ptrOffset = JSDocEnd::offsetOfWrapped();
 
 void JSDocEnd::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -5934,75 +6388,89 @@ void JSDocEnd::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSDocEnd::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSDocEndPrototype::create(vm, globalObject, JSDocEndPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue DocEnd__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSDocEndStructure();
-    JSDocEnd* instance = JSDocEnd::create(vm, globalObject, structure, ptr);
+extern "C" EncodedJSValue DocEnd__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSDocEndStructure();
+  JSDocEnd* instance = JSDocEnd::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSDocTypePrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSDocTypePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSDocTypePrototype* ptr = new (NotNull, JSC::allocateCell<JSDocTypePrototype>(vm)) JSDocTypePrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDocTypePrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSDocTypePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    return JSValue::encode(instance);
-}
-class JSDocTypePrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+extern "C" void* DocTypeClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsDocTypeConstructor);
 
-    static JSDocTypePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSDocTypePrototype* ptr = new (NotNull, JSC::allocateCell<JSDocTypePrototype>(vm)) JSDocTypePrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDocTypePrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSDocTypePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* DocTypeClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsDocTypeConstructor);
 
 extern "C" void DocTypeClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue DocTypePrototype__name(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DocTypePrototype__nameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DocTypePrototype__publicId(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DocTypePrototype__publicIdGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue DocTypePrototype__systemId(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(DocTypePrototype__systemIdGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSDocTypePrototype, JSDocTypePrototype::Base);
 
-static const HashTableValue JSDocTypePrototypeTableValues[] = {
-    { "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DocTypePrototype__nameGetterWrap, 0 } },
-    { "publicId"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DocTypePrototype__publicIdGetterWrap, 0 } },
-    { "systemId"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DocTypePrototype__systemIdGetterWrap, 0 } }
+
+  static const HashTableValue JSDocTypePrototypeTableValues[] = {
+{ "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DocTypePrototype__nameGetterWrap, 0 } }  ,
+{ "publicId"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DocTypePrototype__publicIdGetterWrap, 0 } }  ,
+{ "systemId"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, DocTypePrototype__systemIdGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSDocTypePrototype::s_info = { "DocType"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDocTypePrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsDocTypeConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -6013,100 +6481,114 @@ JSC_DEFINE_CUSTOM_GETTER(jsDocTypeConstructor, (JSGlobalObject * lexicalGlobalOb
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for DocType"_s);
     return JSValue::encode(globalObject->JSDocTypeConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(DocTypePrototype__nameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDocType* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_name.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DocTypePrototype__name(thisObject->wrapped(), globalObject));
+        DocTypePrototype__name(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_name.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DocTypePrototype__nameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
-    thisObject->m_name.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DocTypePrototype__nameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DocTypePrototype__nameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
+      thisObject->m_name.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DocTypePrototype__nameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_name.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(DocTypePrototype__publicIdGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDocType* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_publicId.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DocTypePrototype__publicId(thisObject->wrapped(), globalObject));
+        DocTypePrototype__publicId(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_publicId.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DocTypePrototype__publicIdSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
-    thisObject->m_publicId.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DocTypePrototype__publicIdGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DocTypePrototype__publicIdSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
+      thisObject->m_publicId.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DocTypePrototype__publicIdGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_publicId.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(DocTypePrototype__systemIdGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSDocType* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_systemId.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        DocTypePrototype__systemId(thisObject->wrapped(), globalObject));
+        DocTypePrototype__systemId(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_systemId.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void DocTypePrototype__systemIdSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
-    thisObject->m_systemId.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue DocTypePrototype__systemIdGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void DocTypePrototype__systemIdSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
+      thisObject->m_systemId.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue DocTypePrototype__systemIdGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSDocType*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_systemId.get());
-}
+  }
+  
+  
 
 void JSDocTypePrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -6125,7 +6607,7 @@ void JSDocType::destroy(JSCell* cell)
 {
     static_cast<JSDocType*>(cell)->JSDocType::~JSDocType();
 }
-
+  
 const ClassInfo JSDocType::s_info = { "DocType"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSDocType) };
 
 void JSDocType::finishCreation(VM& vm)
@@ -6134,38 +6616,37 @@ void JSDocType::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSDocType* JSDocType::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSDocType* ptr = new (NotNull, JSC::allocateCell<JSDocType>(vm)) JSDocType(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* DocType__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSDocType* JSDocType::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSDocType* ptr = new (NotNull, JSC::allocateCell<JSDocType>(vm)) JSDocType(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSDocType* object = JSC::jsDynamicCast<JSDocType*>(cell);
+extern "C" void* DocType__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSDocType* object = JSC::jsDynamicCast<JSDocType*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool DocType__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSDocType* object = JSC::jsDynamicCast<JSDocType*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool DocType__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSDocType* object = JSC::jsDynamicCast<JSDocType*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t DocType__ptrOffset = JSDocType::offsetOfWrapped();
 
 void JSDocType::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -6178,18 +6659,19 @@ void JSDocType::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSDocType::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSDocTypePrototype::create(vm, globalObject, JSDocTypePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue DocType__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSDocTypeStructure();
-    JSDocType* instance = JSDocType::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue DocType__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSDocTypeStructure();
+  JSDocType* instance = JSDocType::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -6198,7 +6680,7 @@ void JSDocType::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSDocType* thisObject = jsCast<JSDocType*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -6207,18 +6689,19 @@ DEFINE_VISIT_CHILDREN(JSDocType);
 template<typename Visitor>
 void JSDocType::visitAdditionalChildren(Visitor& visitor)
 {
-    JSDocType* thisObject = this;
+  JSDocType* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_name);
+    
+        visitor.append(thisObject->m_name);
     visitor.append(thisObject->m_publicId);
     visitor.append(thisObject->m_systemId);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSDocType);
 
 template<typename Visitor>
-void JSDocType::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSDocType::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSDocType* thisObject = jsCast<JSDocType*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -6226,129 +6709,159 @@ void JSDocType::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSDocType);
-class JSElementPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSElementPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSElementPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSElementPrototype* ptr = new (NotNull, JSC::allocateCell<JSElementPrototype>(vm)) JSElementPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSElementPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSElementPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSElementPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSElementPrototype* ptr = new (NotNull, JSC::allocateCell<JSElementPrototype>(vm)) JSElementPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* ElementClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsElementConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSElementPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSElementPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* ElementClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsElementConstructor);
 
 extern "C" void ElementClass__finalize(void*);
 
+
 extern "C" EncodedJSValue ElementPrototype__after(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__afterCallback);
 
+
 extern "C" EncodedJSValue ElementPrototype__append(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__appendCallback);
 
+
 extern "C" JSC::EncodedJSValue ElementPrototype__getAttributes(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ElementPrototype__attributesGetterWrap);
 
+
 extern "C" EncodedJSValue ElementPrototype__before(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__beforeCallback);
 
+
 extern "C" JSC::EncodedJSValue ElementPrototype__getCanHaveContent(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ElementPrototype__canHaveContentGetterWrap);
 
+
 extern "C" EncodedJSValue ElementPrototype__getAttribute(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__getAttributeCallback);
 
+
 extern "C" EncodedJSValue ElementPrototype__hasAttribute(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__hasAttributeCallback);
 
+
 extern "C" JSC::EncodedJSValue ElementPrototype__getNamespaceURI(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ElementPrototype__namespaceURIGetterWrap);
 
+
 extern "C" EncodedJSValue ElementPrototype__onEndTag(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__onEndTagCallback);
 
+
 extern "C" EncodedJSValue ElementPrototype__prepend(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__prependCallback);
 
+
 extern "C" EncodedJSValue ElementPrototype__remove(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__removeCallback);
 
+
 extern "C" EncodedJSValue ElementPrototype__removeAndKeepContent(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__removeAndKeepContentCallback);
 
+
 extern "C" EncodedJSValue ElementPrototype__removeAttribute(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__removeAttributeCallback);
 
+
 extern "C" JSC::EncodedJSValue ElementPrototype__getRemoved(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ElementPrototype__removedGetterWrap);
 
+
 extern "C" EncodedJSValue ElementPrototype__replace(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__replaceCallback);
 
+
 extern "C" JSC::EncodedJSValue ElementPrototype__getSelfClosing(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ElementPrototype__selfClosingGetterWrap);
 
+
 extern "C" EncodedJSValue ElementPrototype__setAttribute(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__setAttributeCallback);
 
+
 extern "C" EncodedJSValue ElementPrototype__setInnerContent(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ElementPrototype__setInnerContentCallback);
 
+
 extern "C" JSC::EncodedJSValue ElementPrototype__getTagName(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ElementPrototype__tagNameGetterWrap);
 
+
 extern "C" bool ElementPrototype__setTagName(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
 JSC_DECLARE_CUSTOM_SETTER(ElementPrototype__tagNameSetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSElementPrototype, JSElementPrototype::Base);
 
-static const HashTableValue JSElementPrototypeTableValues[] = {
-    { "after"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__afterCallback, 1 } },
-    { "append"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__appendCallback, 1 } },
-    { "attributes"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__attributesGetterWrap, 0 } },
-    { "before"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__beforeCallback, 1 } },
-    { "canHaveContent"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__canHaveContentGetterWrap, 0 } },
-    { "getAttribute"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__getAttributeCallback, 1 } },
-    { "hasAttribute"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__hasAttributeCallback, 1 } },
-    { "namespaceURI"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__namespaceURIGetterWrap, 0 } },
-    { "onEndTag"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__onEndTagCallback, 1 } },
-    { "prepend"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__prependCallback, 1 } },
-    { "remove"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__removeCallback, 0 } },
-    { "removeAndKeepContent"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__removeAndKeepContentCallback, 0 } },
-    { "removeAttribute"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__removeAttributeCallback, 1 } },
-    { "removed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__removedGetterWrap, 0 } },
-    { "replace"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__replaceCallback, 1 } },
-    { "selfClosing"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__selfClosingGetterWrap, 0 } },
-    { "setAttribute"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__setAttributeCallback, 2 } },
-    { "setInnerContent"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__setInnerContentCallback, 1 } },
-    { "tagName"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__tagNameGetterWrap, ElementPrototype__tagNameSetterWrap } }
+
+  static const HashTableValue JSElementPrototypeTableValues[] = {
+{ "after"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__afterCallback, 1 } }  ,
+{ "append"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__appendCallback, 1 } }  ,
+{ "attributes"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__attributesGetterWrap, 0 } }  ,
+{ "before"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__beforeCallback, 1 } }  ,
+{ "canHaveContent"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__canHaveContentGetterWrap, 0 } }  ,
+{ "getAttribute"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__getAttributeCallback, 1 } }  ,
+{ "hasAttribute"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__hasAttributeCallback, 1 } }  ,
+{ "namespaceURI"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__namespaceURIGetterWrap, 0 } }  ,
+{ "onEndTag"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__onEndTagCallback, 1 } }  ,
+{ "prepend"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__prependCallback, 1 } }  ,
+{ "remove"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__removeCallback, 0 } }  ,
+{ "removeAndKeepContent"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__removeAndKeepContentCallback, 0 } }  ,
+{ "removeAttribute"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__removeAttributeCallback, 1 } }  ,
+{ "removed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__removedGetterWrap, 0 } }  ,
+{ "replace"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__replaceCallback, 1 } }  ,
+{ "selfClosing"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__selfClosingGetterWrap, 0 } }  ,
+{ "setAttribute"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__setAttributeCallback, 2 } }  ,
+{ "setInnerContent"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ElementPrototype__setInnerContentCallback, 1 } }  ,
+{ "tagName"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ElementPrototype__tagNameGetterWrap, ElementPrototype__tagNameSetterWrap } }
 };
 
+
+
 const ClassInfo JSElementPrototype::s_info = { "Element"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSElementPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsElementConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -6359,68 +6872,72 @@ JSC_DEFINE_CUSTOM_GETTER(jsElementConstructor, (JSGlobalObject * lexicalGlobalOb
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Element"_s);
     return JSValue::encode(globalObject->JSElementConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__afterCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__afterCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return ElementPrototype__after(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ElementPrototype__after(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__appendCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__appendCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__append(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ElementPrototype__append(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__attributesGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSElement* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -6428,39 +6945,41 @@ JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__attributesGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__beforeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__beforeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return ElementPrototype__before(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return ElementPrototype__before(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__canHaveContentGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSElement* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -6468,238 +6987,250 @@ JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__canHaveContentGetterWrap, (JSGlobalOb
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__getAttributeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__getAttributeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__getAttribute(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ElementPrototype__getAttribute(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__hasAttributeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__hasAttributeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__hasAttribute(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ElementPrototype__hasAttribute(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__namespaceURIGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSElement* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_namespaceURI.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ElementPrototype__getNamespaceURI(thisObject->wrapped(), globalObject));
+        ElementPrototype__getNamespaceURI(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_namespaceURI.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ElementPrototype__namespaceURISetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
-    thisObject->m_namespaceURI.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ElementPrototype__namespaceURIGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ElementPrototype__namespaceURISetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
+      thisObject->m_namespaceURI.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ElementPrototype__namespaceURIGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_namespaceURI.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__onEndTagCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__onEndTagCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return ElementPrototype__onEndTag(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ElementPrototype__onEndTag(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__prependCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__prependCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__prepend(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ElementPrototype__prepend(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__removeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__removeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__remove(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ElementPrototype__remove(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__removeAndKeepContentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__removeAndKeepContentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__removeAndKeepContent(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ElementPrototype__removeAndKeepContent(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__removeAttributeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__removeAttributeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__removeAttribute(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ElementPrototype__removeAttribute(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__removedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSElement* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -6707,39 +7238,41 @@ JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__removedGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__replaceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__replaceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return ElementPrototype__replace(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return ElementPrototype__replace(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__selfClosingGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSElement* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -6747,67 +7280,70 @@ JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__selfClosingGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__setAttributeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__setAttributeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__setAttribute(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ElementPrototype__setAttribute(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ElementPrototype__setInnerContentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ElementPrototype__setInnerContentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
 
-    JSElement* thisObject = jsDynamicCast<JSElement*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Element"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ElementPrototype__setInnerContent(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ElementPrototype__setInnerContent(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__tagNameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSElement* thisObject = jsCast<JSElement*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -6815,6 +7351,7 @@ JSC_DEFINE_CUSTOM_GETTER(ElementPrototype__tagNameGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_SETTER(ElementPrototype__tagNameSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
 {
@@ -6827,6 +7364,7 @@ JSC_DEFINE_CUSTOM_SETTER(ElementPrototype__tagNameSetterWrap, (JSGlobalObject *
     RELEASE_AND_RETURN(throwScope, result);
 }
 
+
 void JSElementPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
@@ -6844,7 +7382,7 @@ void JSElement::destroy(JSCell* cell)
 {
     static_cast<JSElement*>(cell)->JSElement::~JSElement();
 }
-
+  
 const ClassInfo JSElement::s_info = { "Element"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSElement) };
 
 void JSElement::finishCreation(VM& vm)
@@ -6853,38 +7391,37 @@ void JSElement::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSElement* JSElement::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSElement* ptr = new (NotNull, JSC::allocateCell<JSElement>(vm)) JSElement(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Element__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSElement* JSElement::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSElement* ptr = new (NotNull, JSC::allocateCell<JSElement>(vm)) JSElement(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSElement* object = JSC::jsDynamicCast<JSElement*>(cell);
+extern "C" void* Element__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSElement* object = JSC::jsDynamicCast<JSElement*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Element__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSElement* object = JSC::jsDynamicCast<JSElement*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Element__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSElement* object = JSC::jsDynamicCast<JSElement*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Element__ptrOffset = JSElement::offsetOfWrapped();
 
 void JSElement::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -6897,18 +7434,19 @@ void JSElement::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSElement::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSElementPrototype::create(vm, globalObject, JSElementPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Element__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSElementStructure();
-    JSElement* instance = JSElement::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Element__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSElementStructure();
+  JSElement* instance = JSElement::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -6917,7 +7455,7 @@ void JSElement::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSElement* thisObject = jsCast<JSElement*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -6926,16 +7464,17 @@ DEFINE_VISIT_CHILDREN(JSElement);
 template<typename Visitor>
 void JSElement::visitAdditionalChildren(Visitor& visitor)
 {
-    JSElement* thisObject = this;
+  JSElement* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_namespaceURI);
+    
+        visitor.append(thisObject->m_namespaceURI);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSElement);
 
 template<typename Visitor>
-void JSElement::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSElement::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSElement* thisObject = jsCast<JSElement*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -6943,69 +7482,84 @@ void JSElement::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSElement);
-class JSEndTagPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSEndTagPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSEndTagPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSEndTagPrototype* ptr = new (NotNull, JSC::allocateCell<JSEndTagPrototype>(vm)) JSEndTagPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSEndTagPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSEndTagPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSEndTagPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSEndTagPrototype* ptr = new (NotNull, JSC::allocateCell<JSEndTagPrototype>(vm)) JSEndTagPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* EndTagClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsEndTagConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSEndTagPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSEndTagPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* EndTagClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsEndTagConstructor);
 
 extern "C" void EndTagClass__finalize(void*);
 
+
 extern "C" EncodedJSValue EndTagPrototype__after(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(EndTagPrototype__afterCallback);
 
+
 extern "C" EncodedJSValue EndTagPrototype__before(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(EndTagPrototype__beforeCallback);
 
+
 extern "C" JSC::EncodedJSValue EndTagPrototype__getName(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(EndTagPrototype__nameGetterWrap);
 
+
 extern "C" bool EndTagPrototype__setName(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
 JSC_DECLARE_CUSTOM_SETTER(EndTagPrototype__nameSetterWrap);
 
+
 extern "C" EncodedJSValue EndTagPrototype__remove(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(EndTagPrototype__removeCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSEndTagPrototype, JSEndTagPrototype::Base);
 
-static const HashTableValue JSEndTagPrototypeTableValues[] = {
-    { "after"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, EndTagPrototype__afterCallback, 1 } },
-    { "before"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, EndTagPrototype__beforeCallback, 1 } },
-    { "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, EndTagPrototype__nameGetterWrap, EndTagPrototype__nameSetterWrap } },
-    { "remove"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, EndTagPrototype__removeCallback, 0 } }
+
+  static const HashTableValue JSEndTagPrototypeTableValues[] = {
+{ "after"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, EndTagPrototype__afterCallback, 1 } }  ,
+{ "before"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, EndTagPrototype__beforeCallback, 1 } }  ,
+{ "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, EndTagPrototype__nameGetterWrap, EndTagPrototype__nameSetterWrap } }  ,
+{ "remove"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, EndTagPrototype__removeCallback, 0 } }
 };
 
+
+
 const ClassInfo JSEndTagPrototype::s_info = { "EndTag"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSEndTagPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsEndTagConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -7016,68 +7570,72 @@ JSC_DEFINE_CUSTOM_GETTER(jsEndTagConstructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for EndTag"_s);
     return JSValue::encode(globalObject->JSEndTagConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(EndTagPrototype__afterCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSEndTag* thisObject = jsDynamicCast<JSEndTag*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(EndTagPrototype__afterCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSEndTag* thisObject = jsDynamicCast<JSEndTag*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof EndTag"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof EndTag"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return EndTagPrototype__after(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return EndTagPrototype__after(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(EndTagPrototype__beforeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(EndTagPrototype__beforeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSEndTag* thisObject = jsDynamicCast<JSEndTag*>(callFrame->thisValue());
 
-    JSEndTag* thisObject = jsDynamicCast<JSEndTag*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof EndTag"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof EndTag"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return EndTagPrototype__before(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return EndTagPrototype__before(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(EndTagPrototype__nameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSEndTag* thisObject = jsCast<JSEndTag*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -7085,6 +7643,7 @@ JSC_DEFINE_CUSTOM_GETTER(EndTagPrototype__nameGetterWrap, (JSGlobalObject * lexi
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_SETTER(EndTagPrototype__nameSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
 {
@@ -7097,33 +7656,35 @@ JSC_DEFINE_CUSTOM_SETTER(EndTagPrototype__nameSetterWrap, (JSGlobalObject * lexi
     RELEASE_AND_RETURN(throwScope, result);
 }
 
-JSC_DEFINE_HOST_FUNCTION(EndTagPrototype__removeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSEndTag* thisObject = jsDynamicCast<JSEndTag*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(EndTagPrototype__removeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof EndTag"_s);
-        return JSValue::encode({});
-    }
+        JSEndTag* thisObject = jsDynamicCast<JSEndTag*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof EndTag"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    return EndTagPrototype__remove(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return EndTagPrototype__remove(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 void JSEndTagPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -7142,7 +7703,7 @@ void JSEndTag::destroy(JSCell* cell)
 {
     static_cast<JSEndTag*>(cell)->JSEndTag::~JSEndTag();
 }
-
+  
 const ClassInfo JSEndTag::s_info = { "EndTag"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSEndTag) };
 
 void JSEndTag::finishCreation(VM& vm)
@@ -7151,38 +7712,37 @@ void JSEndTag::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSEndTag* JSEndTag::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSEndTag* ptr = new (NotNull, JSC::allocateCell<JSEndTag>(vm)) JSEndTag(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* EndTag__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSEndTag* JSEndTag::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSEndTag* ptr = new (NotNull, JSC::allocateCell<JSEndTag>(vm)) JSEndTag(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSEndTag* object = JSC::jsDynamicCast<JSEndTag*>(cell);
+extern "C" void* EndTag__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSEndTag* object = JSC::jsDynamicCast<JSEndTag*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool EndTag__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSEndTag* object = JSC::jsDynamicCast<JSEndTag*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool EndTag__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSEndTag* object = JSC::jsDynamicCast<JSEndTag*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t EndTag__ptrOffset = JSEndTag::offsetOfWrapped();
 
 void JSEndTag::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -7195,90 +7755,96 @@ void JSEndTag::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSEndTag::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSEndTagPrototype::create(vm, globalObject, JSEndTagPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue EndTag__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSEndTagStructure();
-    JSEndTag* instance = JSEndTag::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSExpectPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSExpectPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSExpectPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectPrototype>(vm)) JSExpectPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSExpectPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue EndTag__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSEndTagStructure();
+  JSEndTag* instance = JSEndTag::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSExpectPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSExpectPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSExpectPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectPrototype>(vm)) JSExpectPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSExpectPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSExpectConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSExpectConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSExpectPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSExpectConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSExpectPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSExpectConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForExpectConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForExpectConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSExpectPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSExpectConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSExpectPrototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSExpectConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForExpectConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForExpectConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectConstructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSExpectPrototype* prototype);
+extern "C" void* ExpectClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsExpectConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSExpectConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSExpectPrototype* prototype);
-};
 
-extern "C" void* ExpectClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsExpectConstructor);
 
 extern "C" void ExpectClass__finalize(void*);
 extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectClass__call);
@@ -7286,274 +7852,345 @@ extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectClass__call);
 extern "C" EncodedJSValue ExpectPrototype__fail(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__failCallback);
 
-extern "C" JSC::EncodedJSValue ExpectPrototype__getNot(void* ptr, JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* lexicalGlobalObject);
+
+extern "C" JSC::EncodedJSValue ExpectPrototype__getNot(void* ptr, JSC::EncodedJSValue thisValue,  JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ExpectPrototype__notGetterWrap);
 
+
 extern "C" EncodedJSValue ExpectPrototype___pass(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__passCallback);
 
-extern "C" JSC::EncodedJSValue ExpectPrototype__getRejects(void* ptr, JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* lexicalGlobalObject);
+
+extern "C" JSC::EncodedJSValue ExpectPrototype__getRejects(void* ptr, JSC::EncodedJSValue thisValue,  JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ExpectPrototype__rejectsGetterWrap);
 
-extern "C" JSC::EncodedJSValue ExpectPrototype__getResolves(void* ptr, JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* lexicalGlobalObject);
+
+extern "C" JSC::EncodedJSValue ExpectPrototype__getResolves(void* ptr, JSC::EncodedJSValue thisValue,  JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ExpectPrototype__resolvesGetterWrap);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBe(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeArray(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeArrayCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeArrayOfSize(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeArrayOfSizeCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeBoolean(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeBooleanCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeCloseTo(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeCloseToCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeDate(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeDateCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeDefined(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeDefinedCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeEmpty(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeEmptyCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeEven(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeEvenCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeFalse(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeFalseCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeFalsy(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeFalsyCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeFinite(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeFiniteCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeFunction(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeFunctionCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeGreaterThan(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeGreaterThanCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeGreaterThanOrEqual(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeGreaterThanOrEqualCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeInstanceOf(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeInstanceOfCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeInteger(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeIntegerCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeLessThan(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeLessThanCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeLessThanOrEqual(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeLessThanOrEqualCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeNaN(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeNaNCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeNegative(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeNegativeCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeNil(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeNilCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeNull(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeNullCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeNumber(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeNumberCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeOdd(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeOddCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBePositive(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBePositiveCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeString(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeStringCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeSymbol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeSymbolCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeTrue(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeTrueCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeTruthy(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeTruthyCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeTypeOf(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeTypeOfCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeUndefined(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeUndefinedCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toBeWithin(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toBeWithinCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toContain(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toContainCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toContainEqual(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toContainEqualCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toEndWith(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toEndWithCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toEqual(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toEqualCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toEqualIgnoringWhitespace(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toEqualIgnoringWhitespaceCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveBeenCalled(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveBeenCalledTimes(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledTimesCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveBeenCalledWith(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledWithCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveBeenLastCalledWith(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveBeenLastCalledWithCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveBeenNthCalledWith(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveBeenNthCalledWithCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveLastReturnedWith(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveLastReturnedWithCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveLengthCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveNthReturnedWith(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveNthReturnedWithCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveProperty(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHavePropertyCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveReturnedTimes(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveReturnedTimesCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toHaveReturnedWith(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toHaveReturnedWithCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toInclude(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toIncludeCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toIncludeRepeated(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toIncludeRepeatedCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toMatch(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toMatchCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toMatchInlineSnapshot(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toMatchInlineSnapshotCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toMatchObject(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toMatchObjectCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toMatchSnapshot(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toMatchSnapshotCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toSatisfy(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toSatisfyCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toStartWith(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toStartWithCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toStrictEqual(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toStrictEqualCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toThrow(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toThrowCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toThrowErrorMatchingInlineSnapshot(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toThrowErrorMatchingInlineSnapshotCallback);
 
+
 extern "C" EncodedJSValue ExpectPrototype__toThrowErrorMatchingSnapshot(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ExpectPrototype__toThrowErrorMatchingSnapshotCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectPrototype, JSExpectPrototype::Base);
 
-static const HashTableValue JSExpectPrototypeTableValues[] = {
-    { "fail"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__failCallback, 1 } },
-    { "not"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectPrototype__notGetterWrap, 0 } },
-    { "pass"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__passCallback, 1 } },
-    { "rejects"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectPrototype__rejectsGetterWrap, 0 } },
-    { "resolves"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectPrototype__resolvesGetterWrap, 0 } },
-    { "toBe"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeCallback, 1 } },
-    { "toBeArray"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeArrayCallback, 0 } },
-    { "toBeArrayOfSize"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeArrayOfSizeCallback, 1 } },
-    { "toBeBoolean"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeBooleanCallback, 0 } },
-    { "toBeCloseTo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeCloseToCallback, 1 } },
-    { "toBeDate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeDateCallback, 0 } },
-    { "toBeDefined"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeDefinedCallback, 0 } },
-    { "toBeEmpty"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeEmptyCallback, 0 } },
-    { "toBeEven"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeEvenCallback, 0 } },
-    { "toBeFalse"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeFalseCallback, 0 } },
-    { "toBeFalsy"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeFalsyCallback, 0 } },
-    { "toBeFinite"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeFiniteCallback, 0 } },
-    { "toBeFunction"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeFunctionCallback, 0 } },
-    { "toBeGreaterThan"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeGreaterThanCallback, 1 } },
-    { "toBeGreaterThanOrEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeGreaterThanOrEqualCallback, 1 } },
-    { "toBeInstanceOf"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeInstanceOfCallback, 1 } },
-    { "toBeInteger"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeIntegerCallback, 0 } },
-    { "toBeLessThan"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeLessThanCallback, 1 } },
-    { "toBeLessThanOrEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeLessThanOrEqualCallback, 1 } },
-    { "toBeNaN"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNaNCallback, 0 } },
-    { "toBeNegative"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNegativeCallback, 0 } },
-    { "toBeNil"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNilCallback, 0 } },
-    { "toBeNull"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNullCallback, 0 } },
-    { "toBeNumber"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNumberCallback, 0 } },
-    { "toBeOdd"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeOddCallback, 0 } },
-    { "toBePositive"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBePositiveCallback, 0 } },
-    { "toBeString"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeStringCallback, 0 } },
-    { "toBeSymbol"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeSymbolCallback, 0 } },
-    { "toBeTrue"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeTrueCallback, 0 } },
-    { "toBeTruthy"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeTruthyCallback, 0 } },
-    { "toBeTypeOf"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeTypeOfCallback, 1 } },
-    { "toBeUndefined"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeUndefinedCallback, 0 } },
-    { "toBeWithin"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeWithinCallback, 2 } },
-    { "toContain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toContainCallback, 1 } },
-    { "toContainEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toContainEqualCallback, 1 } },
-    { "toEndWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toEndWithCallback, 1 } },
-    { "toEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toEqualCallback, 1 } },
-    { "toEqualIgnoringWhitespace"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toEqualIgnoringWhitespaceCallback, 1 } },
-    { "toHaveBeenCalled"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenCalledCallback, 0 } },
-    { "toHaveBeenCalledTimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenCalledTimesCallback, 1 } },
-    { "toHaveBeenCalledWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenCalledWithCallback, 1 } },
-    { "toHaveBeenLastCalledWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenLastCalledWithCallback, 1 } },
-    { "toHaveBeenNthCalledWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenNthCalledWithCallback, 1 } },
-    { "toHaveLastReturnedWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveLastReturnedWithCallback, 1 } },
-    { "toHaveLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveLengthCallback, 1 } },
-    { "toHaveNthReturnedWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveNthReturnedWithCallback, 1 } },
-    { "toHaveProperty"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHavePropertyCallback, 2 } },
-    { "toHaveReturnedTimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveReturnedTimesCallback, 1 } },
-    { "toHaveReturnedWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveReturnedWithCallback, 1 } },
-    { "toInclude"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toIncludeCallback, 1 } },
-    { "toIncludeRepeated"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toIncludeRepeatedCallback, 2 } },
-    { "toMatch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toMatchCallback, 1 } },
-    { "toMatchInlineSnapshot"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toMatchInlineSnapshotCallback, 1 } },
-    { "toMatchObject"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toMatchObjectCallback, 1 } },
-    { "toMatchSnapshot"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toMatchSnapshotCallback, 1 } },
-    { "toSatisfy"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toSatisfyCallback, 1 } },
-    { "toStartWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toStartWithCallback, 1 } },
-    { "toStrictEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toStrictEqualCallback, 1 } },
-    { "toThrow"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toThrowCallback, 1 } },
-    { "toThrowErrorMatchingInlineSnapshot"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toThrowErrorMatchingInlineSnapshotCallback, 1 } },
-    { "toThrowErrorMatchingSnapshot"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toThrowErrorMatchingSnapshotCallback, 1 } }
+
+  static const HashTableValue JSExpectPrototypeTableValues[] = {
+{ "fail"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__failCallback, 1 } }  ,
+{ "not"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectPrototype__notGetterWrap, 0 } }  ,
+{ "pass"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__passCallback, 1 } }  ,
+{ "rejects"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectPrototype__rejectsGetterWrap, 0 } }  ,
+{ "resolves"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectPrototype__resolvesGetterWrap, 0 } }  ,
+{ "toBe"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeCallback, 1 } }  ,
+{ "toBeArray"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeArrayCallback, 0 } }  ,
+{ "toBeArrayOfSize"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeArrayOfSizeCallback, 1 } }  ,
+{ "toBeBoolean"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeBooleanCallback, 0 } }  ,
+{ "toBeCloseTo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeCloseToCallback, 1 } }  ,
+{ "toBeDate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeDateCallback, 0 } }  ,
+{ "toBeDefined"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeDefinedCallback, 0 } }  ,
+{ "toBeEmpty"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeEmptyCallback, 0 } }  ,
+{ "toBeEven"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeEvenCallback, 0 } }  ,
+{ "toBeFalse"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeFalseCallback, 0 } }  ,
+{ "toBeFalsy"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeFalsyCallback, 0 } }  ,
+{ "toBeFinite"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeFiniteCallback, 0 } }  ,
+{ "toBeFunction"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeFunctionCallback, 0 } }  ,
+{ "toBeGreaterThan"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeGreaterThanCallback, 1 } }  ,
+{ "toBeGreaterThanOrEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeGreaterThanOrEqualCallback, 1 } }  ,
+{ "toBeInstanceOf"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeInstanceOfCallback, 1 } }  ,
+{ "toBeInteger"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeIntegerCallback, 0 } }  ,
+{ "toBeLessThan"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeLessThanCallback, 1 } }  ,
+{ "toBeLessThanOrEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeLessThanOrEqualCallback, 1 } }  ,
+{ "toBeNaN"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNaNCallback, 0 } }  ,
+{ "toBeNegative"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNegativeCallback, 0 } }  ,
+{ "toBeNil"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNilCallback, 0 } }  ,
+{ "toBeNull"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNullCallback, 0 } }  ,
+{ "toBeNumber"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeNumberCallback, 0 } }  ,
+{ "toBeOdd"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeOddCallback, 0 } }  ,
+{ "toBePositive"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBePositiveCallback, 0 } }  ,
+{ "toBeString"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeStringCallback, 0 } }  ,
+{ "toBeSymbol"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeSymbolCallback, 0 } }  ,
+{ "toBeTrue"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeTrueCallback, 0 } }  ,
+{ "toBeTruthy"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeTruthyCallback, 0 } }  ,
+{ "toBeTypeOf"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeTypeOfCallback, 1 } }  ,
+{ "toBeUndefined"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeUndefinedCallback, 0 } }  ,
+{ "toBeWithin"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toBeWithinCallback, 2 } }  ,
+{ "toContain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toContainCallback, 1 } }  ,
+{ "toContainEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toContainEqualCallback, 1 } }  ,
+{ "toEndWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toEndWithCallback, 1 } }  ,
+{ "toEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toEqualCallback, 1 } }  ,
+{ "toEqualIgnoringWhitespace"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toEqualIgnoringWhitespaceCallback, 1 } }  ,
+{ "toHaveBeenCalled"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenCalledCallback, 0 } }  ,
+{ "toHaveBeenCalledTimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenCalledTimesCallback, 1 } }  ,
+{ "toHaveBeenCalledWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenCalledWithCallback, 1 } }  ,
+{ "toHaveBeenLastCalledWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenLastCalledWithCallback, 1 } }  ,
+{ "toHaveBeenNthCalledWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveBeenNthCalledWithCallback, 1 } }  ,
+{ "toHaveLastReturnedWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveLastReturnedWithCallback, 1 } }  ,
+{ "toHaveLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveLengthCallback, 1 } }  ,
+{ "toHaveNthReturnedWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveNthReturnedWithCallback, 1 } }  ,
+{ "toHaveProperty"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHavePropertyCallback, 2 } }  ,
+{ "toHaveReturnedTimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveReturnedTimesCallback, 1 } }  ,
+{ "toHaveReturnedWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toHaveReturnedWithCallback, 1 } }  ,
+{ "toInclude"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toIncludeCallback, 1 } }  ,
+{ "toIncludeRepeated"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toIncludeRepeatedCallback, 2 } }  ,
+{ "toMatch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toMatchCallback, 1 } }  ,
+{ "toMatchInlineSnapshot"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toMatchInlineSnapshotCallback, 1 } }  ,
+{ "toMatchObject"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toMatchObjectCallback, 1 } }  ,
+{ "toMatchSnapshot"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toMatchSnapshotCallback, 1 } }  ,
+{ "toSatisfy"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toSatisfyCallback, 1 } }  ,
+{ "toStartWith"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toStartWithCallback, 1 } }  ,
+{ "toStrictEqual"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toStrictEqualCallback, 1 } }  ,
+{ "toThrow"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toThrowCallback, 1 } }  ,
+{ "toThrowErrorMatchingInlineSnapshot"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toThrowErrorMatchingInlineSnapshotCallback, 1 } }  ,
+{ "toThrowErrorMatchingSnapshot"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectPrototype__toThrowErrorMatchingSnapshotCallback, 1 } }
 };
 
+
+
 const ClassInfo JSExpectPrototype::s_info = { "Expect"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsExpectConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -7564,1833 +8201,1907 @@ JSC_DEFINE_CUSTOM_GETTER(jsExpectConstructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Expect"_s);
     return JSValue::encode(globalObject->JSExpectConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__failCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__failCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    return ExpectPrototype__fail(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return ExpectPrototype__fail(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ExpectPrototype__notGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSExpect* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-    JSC::EncodedJSValue result = ExpectPrototype__getNot(thisObject->wrapped(), thisValue, globalObject);
+    JSC::EncodedJSValue result = ExpectPrototype__getNot(thisObject->wrapped(), thisValue,  globalObject);
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__passCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__passCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return ExpectPrototype___pass(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return ExpectPrototype___pass(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ExpectPrototype__rejectsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSExpect* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-    JSC::EncodedJSValue result = ExpectPrototype__getRejects(thisObject->wrapped(), thisValue, globalObject);
+    JSC::EncodedJSValue result = ExpectPrototype__getRejects(thisObject->wrapped(), thisValue,  globalObject);
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(ExpectPrototype__resolvesGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSExpect* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-    JSC::EncodedJSValue result = ExpectPrototype__getResolves(thisObject->wrapped(), thisValue, globalObject);
+    JSC::EncodedJSValue result = ExpectPrototype__getResolves(thisObject->wrapped(), thisValue,  globalObject);
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
-
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
-
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
-
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    return ExpectPrototype__toBe(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeArrayCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
+        return ExpectPrototype__toBe(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeArrayCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    return ExpectPrototype__toBeArray(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeArrayOfSizeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
+        return ExpectPrototype__toBeArray(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeArrayOfSizeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    return ExpectPrototype__toBeArrayOfSize(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeBooleanCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
+        return ExpectPrototype__toBeArrayOfSize(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeBooleanCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    return ExpectPrototype__toBeBoolean(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeCloseToCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
+        return ExpectPrototype__toBeBoolean(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeCloseToCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    return ExpectPrototype__toBeCloseTo(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeDateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
+        return ExpectPrototype__toBeCloseTo(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeDateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    return ExpectPrototype__toBeDate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeDefinedCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
+        return ExpectPrototype__toBeDate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeDefinedCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    return ExpectPrototype__toBeDefined(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeEmptyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
+        return ExpectPrototype__toBeDefined(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
-
-    return ExpectPrototype__toBeEmpty(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeEmptyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeEvenCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeEmpty(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeEven(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeEvenCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeFalseCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeEven(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeFalse(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeFalseCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeFalsyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeFalse(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeFalsy(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeFalsyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeFiniteCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeFalsy(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeFinite(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeFiniteCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeFunctionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeFinite(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeFunction(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeFunctionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeGreaterThanCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeFunction(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeGreaterThan(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeGreaterThanCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeGreaterThanOrEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeGreaterThan(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeGreaterThanOrEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeGreaterThanOrEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeInstanceOfCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeGreaterThanOrEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeInstanceOf(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeInstanceOfCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeIntegerCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeInstanceOf(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeInteger(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeIntegerCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeLessThanCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeInteger(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeLessThan(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeLessThanCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeLessThanOrEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeLessThan(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeLessThanOrEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeLessThanOrEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNaNCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeLessThanOrEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeNaN(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNaNCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNegativeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeNaN(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeNegative(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNegativeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNilCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeNegative(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeNil(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNilCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNullCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeNil(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeNull(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNullCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNumberCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeNull(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeNumber(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeNumberCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeOddCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeNumber(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeOdd(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeOddCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBePositiveCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeOdd(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBePositive(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBePositiveCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeStringCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBePositive(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeString(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeStringCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeSymbolCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeString(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeSymbol(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeSymbolCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeTrueCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeSymbol(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeTrue(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeTrueCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeTruthyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeTrue(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeTruthy(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeTruthyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeTypeOfCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeTruthy(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeTypeOf(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeTypeOfCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeUndefinedCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeTypeOf(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeUndefined(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeUndefinedCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeWithinCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeUndefined(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toBeWithin(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toBeWithinCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toContainCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toBeWithin(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toContain(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toContainCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toContainEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toContain(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toContainEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toContainEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toEndWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toContainEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toEndWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toEndWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toEndWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toEqualIgnoringWhitespaceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toEqualIgnoringWhitespace(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toEqualIgnoringWhitespaceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toEqualIgnoringWhitespace(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveBeenCalled(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledTimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveBeenCalled(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveBeenCalledTimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledTimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveBeenCalledTimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveBeenCalledWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenCalledWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenLastCalledWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveBeenCalledWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveBeenLastCalledWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenLastCalledWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenNthCalledWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveBeenLastCalledWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveBeenNthCalledWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveBeenNthCalledWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveLastReturnedWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveBeenNthCalledWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveLastReturnedWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveLastReturnedWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveLengthCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveLastReturnedWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveLength(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveLengthCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveNthReturnedWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveLength(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveNthReturnedWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveNthReturnedWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHavePropertyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveNthReturnedWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveProperty(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHavePropertyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveReturnedTimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveProperty(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveReturnedTimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveReturnedTimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveReturnedWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveReturnedTimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toHaveReturnedWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toHaveReturnedWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toIncludeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toHaveReturnedWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toInclude(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toIncludeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toIncludeRepeatedCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toInclude(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toIncludeRepeated(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toIncludeRepeatedCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toMatchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toIncludeRepeated(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toMatch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toMatchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toMatchInlineSnapshotCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toMatch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toMatchInlineSnapshot(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toMatchInlineSnapshotCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toMatchObjectCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toMatchInlineSnapshot(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toMatchObject(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toMatchObjectCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toMatchSnapshotCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toMatchObject(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toMatchSnapshot(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toMatchSnapshotCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toSatisfyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toMatchSnapshot(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toSatisfy(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toSatisfyCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toStartWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toSatisfy(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toStartWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toStartWithCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toStrictEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toStartWith(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toStrictEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toStrictEqualCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toThrowCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toStrictEqual(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toThrow(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toThrowCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toThrowErrorMatchingInlineSnapshotCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toThrow(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toThrowErrorMatchingInlineSnapshot(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toThrowErrorMatchingInlineSnapshotCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toThrowErrorMatchingSnapshotCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
 
-    JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ExpectPrototype__toThrowErrorMatchingInlineSnapshot(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ExpectPrototype__toThrowErrorMatchingSnapshot(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
-
-extern "C" void ExpectPrototype__capturedValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
-    thisObject->m_capturedValue.set(vm, thisObject, JSValue::decode(value));
-}
-
-extern "C" EncodedJSValue ExpectPrototype__capturedValueGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+    JSC_DEFINE_HOST_FUNCTION(ExpectPrototype__toThrowErrorMatchingSnapshotCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSExpect* thisObject = jsDynamicCast<JSExpect*>(callFrame->thisValue());
+
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Expect"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return ExpectPrototype__toThrowErrorMatchingSnapshot(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
+
+
+  extern "C" void ExpectPrototype__capturedValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
+      thisObject->m_capturedValue.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ExpectPrototype__capturedValueGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_capturedValue.get());
-}
-
-extern "C" void ExpectPrototype__resultValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
-    thisObject->m_resultValue.set(vm, thisObject, JSValue::decode(value));
-}
-
-extern "C" EncodedJSValue ExpectPrototype__resultValueGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  }
+  
+  
+
+
+  extern "C" void ExpectPrototype__resultValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
+      thisObject->m_resultValue.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ExpectPrototype__resultValueGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSExpect*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_resultValue.get());
-}
+  }
+  
+  
 
 void JSExpectPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -9413,22 +10124,23 @@ extern "C" JSC_DECLARE_CUSTOM_GETTER(ExpectClass__getStaticResolves);
 extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectClass__stringContaining);
 extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectClass__stringMatching);
 
-static const HashTableValue JSExpectConstructorTableValues[] = {
-    { "addSnapshotSerializer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__addSnapshotSerializer, 1 } },
-    { "any"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__any, 1 } },
-    { "anything"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__anything, 1 } },
-    { "arrayContaining"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__arrayContaining, 1 } },
-    { "assertions"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__assertions, 1 } },
-    { "extend"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__extend, 1 } },
-    { "hasAssertions"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__hasAssertions, 1 } },
-    { "not"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectClass__getStaticNot, 0 } },
-    { "objectContaining"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__objectContaining, 1 } },
-    { "rejects"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectClass__getStaticRejects, 0 } },
-    { "resolves"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectClass__getStaticResolves, 0 } },
-    { "stringContaining"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__stringContaining, 1 } },
-    { "stringMatching"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__stringMatching, 1 } }
+  static const HashTableValue JSExpectConstructorTableValues[] = {
+{ "addSnapshotSerializer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__addSnapshotSerializer, 1 } }  ,
+{ "any"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__any, 1 } }  ,
+{ "anything"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__anything, 1 } }  ,
+{ "arrayContaining"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__arrayContaining, 1 } }  ,
+{ "assertions"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__assertions, 1 } }  ,
+{ "extend"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__extend, 1 } }  ,
+{ "hasAssertions"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__hasAssertions, 1 } }  ,
+{ "not"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectClass__getStaticNot, 0 } }  ,
+{ "objectContaining"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__objectContaining, 1 } }  ,
+{ "rejects"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectClass__getStaticRejects, 0 } }  ,
+{ "resolves"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ExpectClass__getStaticResolves, 0 } }  ,
+{ "stringContaining"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__stringContaining, 1 } }  ,
+{ "stringMatching"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ExpectClass__stringMatching, 1 } }
 };
 
+
 void JSExpectConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSExpectPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "Expect"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -9437,59 +10149,62 @@ void JSExpectConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObje
     ASSERT(inherits(info()));
 }
 
-JSExpectConstructor::JSExpectConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, ExpectClass__call, construct)
-{
-}
+JSExpectConstructor::JSExpectConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, ExpectClass__call, construct) {
 
-JSExpectConstructor* JSExpectConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSExpectPrototype* prototype)
-{
+  }
+
+JSExpectConstructor* JSExpectConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSExpectPrototype* prototype) {
     JSExpectConstructor* ptr = new (NotNull, JSC::allocateCell<JSExpectConstructor>(vm)) JSExpectConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSExpectConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSExpectConstructor();
     Structure* structure = globalObject->JSExpectStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSExpectStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSExpectStructure()
+      );
     }
 
     void* ptr = ExpectClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSExpect* instance = JSExpect::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSExpectConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSExpectPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSExpectConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectConstructor) };
 
-extern "C" EncodedJSValue Expect__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue Expect__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSExpectConstructor());
-}
+  }
 
 JSExpect::~JSExpect()
 {
@@ -9501,7 +10216,7 @@ void JSExpect::destroy(JSCell* cell)
 {
     static_cast<JSExpect*>(cell)->JSExpect::~JSExpect();
 }
-
+  
 const ClassInfo JSExpect::s_info = { "Expect"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpect) };
 
 void JSExpect::finishCreation(VM& vm)
@@ -9510,38 +10225,37 @@ void JSExpect::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSExpect* JSExpect::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSExpect* ptr = new (NotNull, JSC::allocateCell<JSExpect>(vm)) JSExpect(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Expect__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSExpect* JSExpect::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSExpect* ptr = new (NotNull, JSC::allocateCell<JSExpect>(vm)) JSExpect(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSExpect* object = JSC::jsDynamicCast<JSExpect*>(cell);
+extern "C" void* Expect__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSExpect* object = JSC::jsDynamicCast<JSExpect*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Expect__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSExpect* object = JSC::jsDynamicCast<JSExpect*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Expect__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSExpect* object = JSC::jsDynamicCast<JSExpect*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Expect__ptrOffset = JSExpect::offsetOfWrapped();
 
 void JSExpect::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -9556,7 +10270,7 @@ void JSExpect::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSExpect::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSExpectConstructor::create(vm, globalObject, WebCore::JSExpectConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSExpectPrototype*>(prototype));
+  return WebCore::JSExpectConstructor::create(vm, globalObject, WebCore::JSExpectConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSExpectPrototype*>(prototype));
 }
 
 JSObject* JSExpect::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -9564,13 +10278,12 @@ JSObject* JSExpect::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSExpectPrototype::create(vm, globalObject, JSExpectPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Expect__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSExpectStructure();
-    JSExpect* instance = JSExpect::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Expect__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSExpectStructure();
+  JSExpect* instance = JSExpect::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -9579,7 +10292,7 @@ void JSExpect::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSExpect* thisObject = jsCast<JSExpect*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -9588,16 +10301,18 @@ DEFINE_VISIT_CHILDREN(JSExpect);
 template<typename Visitor>
 void JSExpect::visitAdditionalChildren(Visitor& visitor)
 {
-    JSExpect* thisObject = this;
+  JSExpect* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_capturedValue);
-    visitor.append(thisObject->m_resultValue);
+visitor.append(thisObject->m_resultValue);
+    
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSExpect);
 
 template<typename Visitor>
-void JSExpect::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSExpect::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSExpect* thisObject = jsCast<JSExpect*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -9605,64 +10320,72 @@ void JSExpect::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSExpect);
-class JSExpectAnyPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSExpectAnyPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSExpectAnyPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSExpectAnyPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectAnyPrototype>(vm)) JSExpectAnyPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectAnyPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSExpectAnyPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSExpectAnyPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSExpectAnyPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectAnyPrototype>(vm)) JSExpectAnyPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void ExpectAnyClass__finalize(void*);
+extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectAnyClass__call);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectAnyPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSExpectAnyPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectAnyPrototype, JSExpectAnyPrototype::Base);
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void ExpectAnyClass__finalize(void*);
-extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectAnyClass__call);
+  static const HashTableValue JSExpectAnyPrototypeTableValues[] = {};
 
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectAnyPrototype, JSExpectAnyPrototype::Base);
 
-static const HashTableValue JSExpectAnyPrototypeTableValues[] = {};
 
 const ClassInfo JSExpectAnyPrototype::s_info = { "ExpectAny"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectAnyPrototype) };
 
-extern "C" void ExpectAnyPrototype__constructorValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSExpectAny*>(JSValue::decode(thisValue));
-    thisObject->m_constructorValue.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ExpectAnyPrototype__constructorValueGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+
+  extern "C" void ExpectAnyPrototype__constructorValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSExpectAny*>(JSValue::decode(thisValue));
+      thisObject->m_constructorValue.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ExpectAnyPrototype__constructorValueGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSExpectAny*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_constructorValue.get());
-}
+  }
+  
+  
 
 void JSExpectAnyPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
-
+    
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
@@ -9676,7 +10399,7 @@ void JSExpectAny::destroy(JSCell* cell)
 {
     static_cast<JSExpectAny*>(cell)->JSExpectAny::~JSExpectAny();
 }
-
+  
 const ClassInfo JSExpectAny::s_info = { "ExpectAny"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectAny) };
 
 void JSExpectAny::finishCreation(VM& vm)
@@ -9685,38 +10408,37 @@ void JSExpectAny::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSExpectAny* JSExpectAny::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSExpectAny* ptr = new (NotNull, JSC::allocateCell<JSExpectAny>(vm)) JSExpectAny(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* ExpectAny__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSExpectAny* JSExpectAny::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSExpectAny* ptr = new (NotNull, JSC::allocateCell<JSExpectAny>(vm)) JSExpectAny(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSExpectAny* object = JSC::jsDynamicCast<JSExpectAny*>(cell);
+extern "C" void* ExpectAny__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSExpectAny* object = JSC::jsDynamicCast<JSExpectAny*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool ExpectAny__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSExpectAny* object = JSC::jsDynamicCast<JSExpectAny*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool ExpectAny__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSExpectAny* object = JSC::jsDynamicCast<JSExpectAny*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t ExpectAny__ptrOffset = JSExpectAny::offsetOfWrapped();
 
 void JSExpectAny::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -9729,18 +10451,19 @@ void JSExpectAny::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSExpectAny::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSExpectAnyPrototype::create(vm, globalObject, JSExpectAnyPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue ExpectAny__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSExpectAnyStructure();
-    JSExpectAny* instance = JSExpectAny::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue ExpectAny__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSExpectAnyStructure();
+  JSExpectAny* instance = JSExpectAny::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -9749,7 +10472,7 @@ void JSExpectAny::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSExpectAny* thisObject = jsCast<JSExpectAny*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -9758,15 +10481,17 @@ DEFINE_VISIT_CHILDREN(JSExpectAny);
 template<typename Visitor>
 void JSExpectAny::visitAdditionalChildren(Visitor& visitor)
 {
-    JSExpectAny* thisObject = this;
+  JSExpectAny* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_constructorValue);
+    
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSExpectAny);
 
 template<typename Visitor>
-void JSExpectAny::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSExpectAny::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSExpectAny* thisObject = jsCast<JSExpectAny*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -9774,51 +10499,57 @@ void JSExpectAny::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSExpectAny);
-class JSExpectAnythingPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSExpectAnythingPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSExpectAnythingPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSExpectAnythingPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectAnythingPrototype>(vm)) JSExpectAnythingPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectAnythingPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSExpectAnythingPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSExpectAnythingPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSExpectAnythingPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectAnythingPrototype>(vm)) JSExpectAnythingPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void ExpectAnythingClass__finalize(void*);
+extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectAnythingClass__call);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectAnythingPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSExpectAnythingPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectAnythingPrototype, JSExpectAnythingPrototype::Base);
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void ExpectAnythingClass__finalize(void*);
-extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectAnythingClass__call);
+  static const HashTableValue JSExpectAnythingPrototypeTableValues[] = {};
 
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectAnythingPrototype, JSExpectAnythingPrototype::Base);
 
-static const HashTableValue JSExpectAnythingPrototypeTableValues[] = {};
 
 const ClassInfo JSExpectAnythingPrototype::s_info = { "ExpectAnything"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectAnythingPrototype) };
 
+
+
 void JSExpectAnythingPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
-
+    
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
@@ -9832,7 +10563,7 @@ void JSExpectAnything::destroy(JSCell* cell)
 {
     static_cast<JSExpectAnything*>(cell)->JSExpectAnything::~JSExpectAnything();
 }
-
+  
 const ClassInfo JSExpectAnything::s_info = { "ExpectAnything"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectAnything) };
 
 void JSExpectAnything::finishCreation(VM& vm)
@@ -9841,38 +10572,37 @@ void JSExpectAnything::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSExpectAnything* JSExpectAnything::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSExpectAnything* ptr = new (NotNull, JSC::allocateCell<JSExpectAnything>(vm)) JSExpectAnything(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* ExpectAnything__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSExpectAnything* JSExpectAnything::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSExpectAnything* ptr = new (NotNull, JSC::allocateCell<JSExpectAnything>(vm)) JSExpectAnything(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSExpectAnything* object = JSC::jsDynamicCast<JSExpectAnything*>(cell);
+extern "C" void* ExpectAnything__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSExpectAnything* object = JSC::jsDynamicCast<JSExpectAnything*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool ExpectAnything__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSExpectAnything* object = JSC::jsDynamicCast<JSExpectAnything*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool ExpectAnything__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSExpectAnything* object = JSC::jsDynamicCast<JSExpectAnything*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t ExpectAnything__ptrOffset = JSExpectAnything::offsetOfWrapped();
 
 void JSExpectAnything::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -9885,77 +10615,86 @@ void JSExpectAnything::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSExpectAnything::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSExpectAnythingPrototype::create(vm, globalObject, JSExpectAnythingPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue ExpectAnything__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSExpectAnythingStructure();
-    JSExpectAnything* instance = JSExpectAnything::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSExpectArrayContainingPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+extern "C" EncodedJSValue ExpectAnything__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSExpectAnythingStructure();
+  JSExpectAnything* instance = JSExpectAnything::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSExpectArrayContainingPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSExpectArrayContainingPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSExpectArrayContainingPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectArrayContainingPrototype>(vm)) JSExpectArrayContainingPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectArrayContainingPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSExpectArrayContainingPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSExpectArrayContainingPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSExpectArrayContainingPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectArrayContainingPrototype>(vm)) JSExpectArrayContainingPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void ExpectArrayContainingClass__finalize(void*);
+extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectArrayContainingClass__call);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectArrayContainingPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSExpectArrayContainingPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectArrayContainingPrototype, JSExpectArrayContainingPrototype::Base);
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void ExpectArrayContainingClass__finalize(void*);
-extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectArrayContainingClass__call);
+  static const HashTableValue JSExpectArrayContainingPrototypeTableValues[] = {};
 
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectArrayContainingPrototype, JSExpectArrayContainingPrototype::Base);
 
-static const HashTableValue JSExpectArrayContainingPrototypeTableValues[] = {};
 
 const ClassInfo JSExpectArrayContainingPrototype::s_info = { "ExpectArrayContaining"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectArrayContainingPrototype) };
 
-extern "C" void ExpectArrayContainingPrototype__arrayValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSExpectArrayContaining*>(JSValue::decode(thisValue));
-    thisObject->m_arrayValue.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ExpectArrayContainingPrototype__arrayValueGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+
+  extern "C" void ExpectArrayContainingPrototype__arrayValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSExpectArrayContaining*>(JSValue::decode(thisValue));
+      thisObject->m_arrayValue.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ExpectArrayContainingPrototype__arrayValueGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSExpectArrayContaining*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_arrayValue.get());
-}
+  }
+  
+  
 
 void JSExpectArrayContainingPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
-
+    
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
@@ -9969,7 +10708,7 @@ void JSExpectArrayContaining::destroy(JSCell* cell)
 {
     static_cast<JSExpectArrayContaining*>(cell)->JSExpectArrayContaining::~JSExpectArrayContaining();
 }
-
+  
 const ClassInfo JSExpectArrayContaining::s_info = { "ExpectArrayContaining"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectArrayContaining) };
 
 void JSExpectArrayContaining::finishCreation(VM& vm)
@@ -9978,38 +10717,37 @@ void JSExpectArrayContaining::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSExpectArrayContaining* JSExpectArrayContaining::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSExpectArrayContaining* ptr = new (NotNull, JSC::allocateCell<JSExpectArrayContaining>(vm)) JSExpectArrayContaining(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* ExpectArrayContaining__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSExpectArrayContaining* JSExpectArrayContaining::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSExpectArrayContaining* ptr = new (NotNull, JSC::allocateCell<JSExpectArrayContaining>(vm)) JSExpectArrayContaining(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSExpectArrayContaining* object = JSC::jsDynamicCast<JSExpectArrayContaining*>(cell);
+extern "C" void* ExpectArrayContaining__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSExpectArrayContaining* object = JSC::jsDynamicCast<JSExpectArrayContaining*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool ExpectArrayContaining__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSExpectArrayContaining* object = JSC::jsDynamicCast<JSExpectArrayContaining*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool ExpectArrayContaining__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSExpectArrayContaining* object = JSC::jsDynamicCast<JSExpectArrayContaining*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t ExpectArrayContaining__ptrOffset = JSExpectArrayContaining::offsetOfWrapped();
 
 void JSExpectArrayContaining::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -10022,18 +10760,19 @@ void JSExpectArrayContaining::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSExpectArrayContaining::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSExpectArrayContainingPrototype::create(vm, globalObject, JSExpectArrayContainingPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue ExpectArrayContaining__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSExpectArrayContainingStructure();
-    JSExpectArrayContaining* instance = JSExpectArrayContaining::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue ExpectArrayContaining__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSExpectArrayContainingStructure();
+  JSExpectArrayContaining* instance = JSExpectArrayContaining::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -10042,7 +10781,7 @@ void JSExpectArrayContaining::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSExpectArrayContaining* thisObject = jsCast<JSExpectArrayContaining*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -10051,15 +10790,17 @@ DEFINE_VISIT_CHILDREN(JSExpectArrayContaining);
 template<typename Visitor>
 void JSExpectArrayContaining::visitAdditionalChildren(Visitor& visitor)
 {
-    JSExpectArrayContaining* thisObject = this;
+  JSExpectArrayContaining* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_arrayValue);
+    
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSExpectArrayContaining);
 
 template<typename Visitor>
-void JSExpectArrayContaining::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSExpectArrayContaining::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSExpectArrayContaining* thisObject = jsCast<JSExpectArrayContaining*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -10067,64 +10808,72 @@ void JSExpectArrayContaining::visitOutputConstraintsImpl(JSCell* cell, Visitor&
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSExpectArrayContaining);
-class JSExpectStringContainingPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSExpectStringContainingPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSExpectStringContainingPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSExpectStringContainingPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectStringContainingPrototype>(vm)) JSExpectStringContainingPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectStringContainingPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSExpectStringContainingPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSExpectStringContainingPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSExpectStringContainingPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectStringContainingPrototype>(vm)) JSExpectStringContainingPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void ExpectStringContainingClass__finalize(void*);
+extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectStringContainingClass__call);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectStringContainingPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSExpectStringContainingPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectStringContainingPrototype, JSExpectStringContainingPrototype::Base);
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void ExpectStringContainingClass__finalize(void*);
-extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectStringContainingClass__call);
+  static const HashTableValue JSExpectStringContainingPrototypeTableValues[] = {};
 
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectStringContainingPrototype, JSExpectStringContainingPrototype::Base);
 
-static const HashTableValue JSExpectStringContainingPrototypeTableValues[] = {};
 
 const ClassInfo JSExpectStringContainingPrototype::s_info = { "ExpectStringContaining"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectStringContainingPrototype) };
 
-extern "C" void ExpectStringContainingPrototype__stringValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSExpectStringContaining*>(JSValue::decode(thisValue));
-    thisObject->m_stringValue.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ExpectStringContainingPrototype__stringValueGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+
+  extern "C" void ExpectStringContainingPrototype__stringValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSExpectStringContaining*>(JSValue::decode(thisValue));
+      thisObject->m_stringValue.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ExpectStringContainingPrototype__stringValueGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSExpectStringContaining*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_stringValue.get());
-}
+  }
+  
+  
 
 void JSExpectStringContainingPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
-
+    
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
@@ -10138,7 +10887,7 @@ void JSExpectStringContaining::destroy(JSCell* cell)
 {
     static_cast<JSExpectStringContaining*>(cell)->JSExpectStringContaining::~JSExpectStringContaining();
 }
-
+  
 const ClassInfo JSExpectStringContaining::s_info = { "ExpectStringContaining"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectStringContaining) };
 
 void JSExpectStringContaining::finishCreation(VM& vm)
@@ -10147,38 +10896,37 @@ void JSExpectStringContaining::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSExpectStringContaining* JSExpectStringContaining::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSExpectStringContaining* ptr = new (NotNull, JSC::allocateCell<JSExpectStringContaining>(vm)) JSExpectStringContaining(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* ExpectStringContaining__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSExpectStringContaining* JSExpectStringContaining::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSExpectStringContaining* ptr = new (NotNull, JSC::allocateCell<JSExpectStringContaining>(vm)) JSExpectStringContaining(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSExpectStringContaining* object = JSC::jsDynamicCast<JSExpectStringContaining*>(cell);
+extern "C" void* ExpectStringContaining__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSExpectStringContaining* object = JSC::jsDynamicCast<JSExpectStringContaining*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool ExpectStringContaining__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSExpectStringContaining* object = JSC::jsDynamicCast<JSExpectStringContaining*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool ExpectStringContaining__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSExpectStringContaining* object = JSC::jsDynamicCast<JSExpectStringContaining*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t ExpectStringContaining__ptrOffset = JSExpectStringContaining::offsetOfWrapped();
 
 void JSExpectStringContaining::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -10191,18 +10939,19 @@ void JSExpectStringContaining::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSExpectStringContaining::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSExpectStringContainingPrototype::create(vm, globalObject, JSExpectStringContainingPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue ExpectStringContaining__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSExpectStringContainingStructure();
-    JSExpectStringContaining* instance = JSExpectStringContaining::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue ExpectStringContaining__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSExpectStringContainingStructure();
+  JSExpectStringContaining* instance = JSExpectStringContaining::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -10211,7 +10960,7 @@ void JSExpectStringContaining::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSExpectStringContaining* thisObject = jsCast<JSExpectStringContaining*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -10220,15 +10969,17 @@ DEFINE_VISIT_CHILDREN(JSExpectStringContaining);
 template<typename Visitor>
 void JSExpectStringContaining::visitAdditionalChildren(Visitor& visitor)
 {
-    JSExpectStringContaining* thisObject = this;
+  JSExpectStringContaining* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_stringValue);
+    
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSExpectStringContaining);
 
 template<typename Visitor>
-void JSExpectStringContaining::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSExpectStringContaining::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSExpectStringContaining* thisObject = jsCast<JSExpectStringContaining*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -10236,64 +10987,72 @@ void JSExpectStringContaining::visitOutputConstraintsImpl(JSCell* cell, Visitor&
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSExpectStringContaining);
-class JSExpectStringMatchingPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSExpectStringMatchingPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSExpectStringMatchingPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSExpectStringMatchingPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectStringMatchingPrototype>(vm)) JSExpectStringMatchingPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectStringMatchingPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSExpectStringMatchingPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSExpectStringMatchingPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSExpectStringMatchingPrototype* ptr = new (NotNull, JSC::allocateCell<JSExpectStringMatchingPrototype>(vm)) JSExpectStringMatchingPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void ExpectStringMatchingClass__finalize(void*);
+extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectStringMatchingClass__call);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectStringMatchingPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSExpectStringMatchingPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectStringMatchingPrototype, JSExpectStringMatchingPrototype::Base);
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void ExpectStringMatchingClass__finalize(void*);
-extern "C" JSC_DECLARE_HOST_FUNCTION(ExpectStringMatchingClass__call);
+  static const HashTableValue JSExpectStringMatchingPrototypeTableValues[] = {};
 
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSExpectStringMatchingPrototype, JSExpectStringMatchingPrototype::Base);
 
-static const HashTableValue JSExpectStringMatchingPrototypeTableValues[] = {};
 
 const ClassInfo JSExpectStringMatchingPrototype::s_info = { "ExpectStringMatching"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectStringMatchingPrototype) };
 
-extern "C" void ExpectStringMatchingPrototype__testValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSExpectStringMatching*>(JSValue::decode(thisValue));
-    thisObject->m_testValue.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ExpectStringMatchingPrototype__testValueGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+
+  extern "C" void ExpectStringMatchingPrototype__testValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSExpectStringMatching*>(JSValue::decode(thisValue));
+      thisObject->m_testValue.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ExpectStringMatchingPrototype__testValueGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSExpectStringMatching*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_testValue.get());
-}
+  }
+  
+  
 
 void JSExpectStringMatchingPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
-
+    
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
@@ -10307,7 +11066,7 @@ void JSExpectStringMatching::destroy(JSCell* cell)
 {
     static_cast<JSExpectStringMatching*>(cell)->JSExpectStringMatching::~JSExpectStringMatching();
 }
-
+  
 const ClassInfo JSExpectStringMatching::s_info = { "ExpectStringMatching"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSExpectStringMatching) };
 
 void JSExpectStringMatching::finishCreation(VM& vm)
@@ -10316,38 +11075,37 @@ void JSExpectStringMatching::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSExpectStringMatching* JSExpectStringMatching::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSExpectStringMatching* ptr = new (NotNull, JSC::allocateCell<JSExpectStringMatching>(vm)) JSExpectStringMatching(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* ExpectStringMatching__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSExpectStringMatching* JSExpectStringMatching::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSExpectStringMatching* ptr = new (NotNull, JSC::allocateCell<JSExpectStringMatching>(vm)) JSExpectStringMatching(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSExpectStringMatching* object = JSC::jsDynamicCast<JSExpectStringMatching*>(cell);
+extern "C" void* ExpectStringMatching__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSExpectStringMatching* object = JSC::jsDynamicCast<JSExpectStringMatching*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool ExpectStringMatching__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSExpectStringMatching* object = JSC::jsDynamicCast<JSExpectStringMatching*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool ExpectStringMatching__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSExpectStringMatching* object = JSC::jsDynamicCast<JSExpectStringMatching*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t ExpectStringMatching__ptrOffset = JSExpectStringMatching::offsetOfWrapped();
 
 void JSExpectStringMatching::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -10360,18 +11118,19 @@ void JSExpectStringMatching::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSExpectStringMatching::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSExpectStringMatchingPrototype::create(vm, globalObject, JSExpectStringMatchingPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue ExpectStringMatching__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSExpectStringMatchingStructure();
-    JSExpectStringMatching* instance = JSExpectStringMatching::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue ExpectStringMatching__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSExpectStringMatchingStructure();
+  JSExpectStringMatching* instance = JSExpectStringMatching::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -10380,7 +11139,7 @@ void JSExpectStringMatching::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSExpectStringMatching* thisObject = jsCast<JSExpectStringMatching*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -10389,15 +11148,17 @@ DEFINE_VISIT_CHILDREN(JSExpectStringMatching);
 template<typename Visitor>
 void JSExpectStringMatching::visitAdditionalChildren(Visitor& visitor)
 {
-    JSExpectStringMatching* thisObject = this;
+  JSExpectStringMatching* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_testValue);
+    
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSExpectStringMatching);
 
 template<typename Visitor>
-void JSExpectStringMatching::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSExpectStringMatching::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSExpectStringMatching* thisObject = jsCast<JSExpectStringMatching*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -10405,58 +11166,70 @@ void JSExpectStringMatching::visitOutputConstraintsImpl(JSCell* cell, Visitor& v
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSExpectStringMatching);
-class JSFFIPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSFFIPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSFFIPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSFFIPrototype* ptr = new (NotNull, JSC::allocateCell<JSFFIPrototype>(vm)) JSFFIPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFFIPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSFFIPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSFFIPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSFFIPrototype* ptr = new (NotNull, JSC::allocateCell<JSFFIPrototype>(vm)) JSFFIPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* FFIClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsFFIConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFFIPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSFFIPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* FFIClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsFFIConstructor);
 
 extern "C" void FFIClass__finalize(void*);
 
+
 extern "C" EncodedJSValue FFIPrototype__close(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(FFIPrototype__closeCallback);
 
+
 extern "C" JSC::EncodedJSValue FFIPrototype__getSymbols(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(FFIPrototype__symbolsGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFFIPrototype, JSFFIPrototype::Base);
 
-static const HashTableValue JSFFIPrototypeTableValues[] = {
-    { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FFIPrototype__closeCallback, 0 } },
-    { "symbols"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, FFIPrototype__symbolsGetterWrap, 0 } }
+
+  static const HashTableValue JSFFIPrototypeTableValues[] = {
+{ "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FFIPrototype__closeCallback, 0 } }  ,
+{ "symbols"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, FFIPrototype__symbolsGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSFFIPrototype::s_info = { "FFI"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFFIPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsFFIConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -10467,79 +11240,89 @@ JSC_DEFINE_CUSTOM_GETTER(jsFFIConstructor, (JSGlobalObject * lexicalGlobalObject
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for FFI"_s);
     return JSValue::encode(globalObject->JSFFIConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(FFIPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSFFI* thisObject = jsDynamicCast<JSFFI*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(FFIPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FFI"_s);
-        return JSValue::encode({});
-    }
+        JSFFI* thisObject = jsDynamicCast<JSFFI*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FFI"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    return FFIPrototype__close(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return FFIPrototype__close(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(FFIPrototype__symbolsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSFFI* thisObject = jsCast<JSFFI*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_symbolsValue.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        FFIPrototype__getSymbols(thisObject->wrapped(), globalObject));
+        FFIPrototype__getSymbols(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_symbolsValue.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void FFIPrototype__symbolsSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSFFI*>(JSValue::decode(thisValue));
-    thisObject->m_symbolsValue.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue FFIPrototype__symbolsGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void FFIPrototype__symbolsSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSFFI*>(JSValue::decode(thisValue));
+      thisObject->m_symbolsValue.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue FFIPrototype__symbolsGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSFFI*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_symbolsValue.get());
-}
-
-extern "C" void FFIPrototype__symbolsValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSFFI*>(JSValue::decode(thisValue));
-    thisObject->m_symbolsValue.set(vm, thisObject, JSValue::decode(value));
-}
-
-extern "C" EncodedJSValue FFIPrototype__symbolsValueGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  }
+  
+  
+
+
+  extern "C" void FFIPrototype__symbolsValueSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSFFI*>(JSValue::decode(thisValue));
+      thisObject->m_symbolsValue.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue FFIPrototype__symbolsValueGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSFFI*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_symbolsValue.get());
-}
+  }
+  
+  
 
 void JSFFIPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -10558,7 +11341,7 @@ void JSFFI::destroy(JSCell* cell)
 {
     static_cast<JSFFI*>(cell)->JSFFI::~JSFFI();
 }
-
+  
 const ClassInfo JSFFI::s_info = { "FFI"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFFI) };
 
 void JSFFI::finishCreation(VM& vm)
@@ -10567,38 +11350,37 @@ void JSFFI::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSFFI* JSFFI::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSFFI* ptr = new (NotNull, JSC::allocateCell<JSFFI>(vm)) JSFFI(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* FFI__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSFFI* JSFFI::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSFFI* ptr = new (NotNull, JSC::allocateCell<JSFFI>(vm)) JSFFI(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSFFI* object = JSC::jsDynamicCast<JSFFI*>(cell);
+extern "C" void* FFI__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSFFI* object = JSC::jsDynamicCast<JSFFI*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool FFI__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSFFI* object = JSC::jsDynamicCast<JSFFI*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool FFI__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSFFI* object = JSC::jsDynamicCast<JSFFI*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t FFI__ptrOffset = JSFFI::offsetOfWrapped();
 
 void JSFFI::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -10611,18 +11393,19 @@ void JSFFI::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSFFI::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSFFIPrototype::create(vm, globalObject, JSFFIPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue FFI__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSFFIStructure();
-    JSFFI* instance = JSFFI::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue FFI__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSFFIStructure();
+  JSFFI* instance = JSFFI::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -10631,7 +11414,7 @@ void JSFFI::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSFFI* thisObject = jsCast<JSFFI*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -10640,15 +11423,17 @@ DEFINE_VISIT_CHILDREN(JSFFI);
 template<typename Visitor>
 void JSFFI::visitAdditionalChildren(Visitor& visitor)
 {
-    JSFFI* thisObject = this;
+  JSFFI* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_symbolsValue);
+    
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSFFI);
 
 template<typename Visitor>
-void JSFFI::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSFFI::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSFFI* thisObject = jsCast<JSFFI*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -10656,187 +11441,203 @@ void JSFFI::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSFFI);
-class JSFSWatcherPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSFSWatcherPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSFSWatcherPrototype* ptr = new (NotNull, JSC::allocateCell<JSFSWatcherPrototype>(vm)) JSFSWatcherPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFSWatcherPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSFSWatcherPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSFSWatcherPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSFSWatcherPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSFSWatcherPrototype* ptr = new (NotNull, JSC::allocateCell<JSFSWatcherPrototype>(vm)) JSFSWatcherPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFSWatcherPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSFSWatcherPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 extern "C" void FSWatcherClass__finalize(void*);
 
+
 extern "C" EncodedJSValue FSWatcherPrototype__doClose(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(FSWatcherPrototype__closeCallback);
 
+
 extern "C" EncodedJSValue FSWatcherPrototype__hasRef(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(FSWatcherPrototype__hasRefCallback);
 
+
 extern "C" EncodedJSValue FSWatcherPrototype__doRef(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(FSWatcherPrototype__refCallback);
 
+
 extern "C" EncodedJSValue FSWatcherPrototype__doUnref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(FSWatcherPrototype__unrefCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFSWatcherPrototype, JSFSWatcherPrototype::Base);
 
-static const HashTableValue JSFSWatcherPrototypeTableValues[] = {
-    { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FSWatcherPrototype__closeCallback, 0 } },
-    { "hasRef"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FSWatcherPrototype__hasRefCallback, 0 } },
-    { "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FSWatcherPrototype__refCallback, 0 } },
-    { "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FSWatcherPrototype__unrefCallback, 0 } }
+
+  static const HashTableValue JSFSWatcherPrototypeTableValues[] = {
+{ "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FSWatcherPrototype__closeCallback, 0 } }  ,
+{ "hasRef"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FSWatcherPrototype__hasRefCallback, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FSWatcherPrototype__refCallback, 0 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FSWatcherPrototype__unrefCallback, 0 } }
 };
 
-const ClassInfo JSFSWatcherPrototype::s_info = { "FSWatcher"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFSWatcherPrototype) };
 
-JSC_DEFINE_HOST_FUNCTION(FSWatcherPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSFSWatcher* thisObject = jsDynamicCast<JSFSWatcher*>(callFrame->thisValue());
+const ClassInfo JSFSWatcherPrototype::s_info = { "FSWatcher"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFSWatcherPrototype) };
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FSWatcher"_s);
-        return JSValue::encode({});
-    }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(FSWatcherPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSFSWatcher* thisObject = jsDynamicCast<JSFSWatcher*>(callFrame->thisValue());
 
-    return FSWatcherPrototype__doClose(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FSWatcher"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(FSWatcherPrototype__hasRefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSFSWatcher* thisObject = jsDynamicCast<JSFSWatcher*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FSWatcher"_s);
-        return JSValue::encode({});
+        return FSWatcherPrototype__doClose(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC_DEFINE_HOST_FUNCTION(FSWatcherPrototype__hasRefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSFSWatcher* thisObject = jsDynamicCast<JSFSWatcher*>(callFrame->thisValue());
 
-    return FSWatcherPrototype__hasRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FSWatcher"_s);
+            return JSValue::encode({});
+        }
 
-JSC_DEFINE_HOST_FUNCTION(FSWatcherPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSFSWatcher* thisObject = jsDynamicCast<JSFSWatcher*>(callFrame->thisValue());
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FSWatcher"_s);
-        return JSValue::encode({});
+        return FSWatcherPrototype__hasRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
+    
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
-
-    return FSWatcherPrototype__doRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(FSWatcherPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(FSWatcherPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSFSWatcher* thisObject = jsDynamicCast<JSFSWatcher*>(callFrame->thisValue());
 
-    JSFSWatcher* thisObject = jsDynamicCast<JSFSWatcher*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FSWatcher"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FSWatcher"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return FSWatcherPrototype__doRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return FSWatcherPrototype__doUnref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
-extern "C" void FSWatcherPrototype__listenerSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSFSWatcher*>(JSValue::decode(thisValue));
-    thisObject->m_listener.set(vm, thisObject, JSValue::decode(value));
-}
-
-extern "C" EncodedJSValue FSWatcherPrototype__listenerGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+    JSC_DEFINE_HOST_FUNCTION(FSWatcherPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSFSWatcher* thisObject = jsDynamicCast<JSFSWatcher*>(callFrame->thisValue());
+
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FSWatcher"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return FSWatcherPrototype__doUnref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
+
+
+  extern "C" void FSWatcherPrototype__listenerSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSFSWatcher*>(JSValue::decode(thisValue));
+      thisObject->m_listener.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue FSWatcherPrototype__listenerGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSFSWatcher*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_listener.get());
-}
+  }
+  
+  
 
 void JSFSWatcherPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -10846,10 +11647,9 @@ void JSFSWatcherPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* glob
 }
 
 extern "C" bool FSWatcher__hasPendingActivity(void* ptr);
-bool JSFSWatcher::hasPendingActivity(void* ctx)
-{
-    return FSWatcher__hasPendingActivity(ctx);
-}
+    bool JSFSWatcher::hasPendingActivity(void* ctx) {
+        return FSWatcher__hasPendingActivity(ctx);
+    }
 
 JSFSWatcher::~JSFSWatcher()
 {
@@ -10861,7 +11661,7 @@ void JSFSWatcher::destroy(JSCell* cell)
 {
     static_cast<JSFSWatcher*>(cell)->JSFSWatcher::~JSFSWatcher();
 }
-
+  
 const ClassInfo JSFSWatcher::s_info = { "FSWatcher"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFSWatcher) };
 
 void JSFSWatcher::finishCreation(VM& vm)
@@ -10870,38 +11670,37 @@ void JSFSWatcher::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSFSWatcher* JSFSWatcher::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSFSWatcher* ptr = new (NotNull, JSC::allocateCell<JSFSWatcher>(vm)) JSFSWatcher(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* FSWatcher__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSFSWatcher* JSFSWatcher::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSFSWatcher* ptr = new (NotNull, JSC::allocateCell<JSFSWatcher>(vm)) JSFSWatcher(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSFSWatcher* object = JSC::jsDynamicCast<JSFSWatcher*>(cell);
+extern "C" void* FSWatcher__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSFSWatcher* object = JSC::jsDynamicCast<JSFSWatcher*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool FSWatcher__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSFSWatcher* object = JSC::jsDynamicCast<JSFSWatcher*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool FSWatcher__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSFSWatcher* object = JSC::jsDynamicCast<JSFSWatcher*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t FSWatcher__ptrOffset = JSFSWatcher::offsetOfWrapped();
 
 void JSFSWatcher::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -10914,18 +11713,19 @@ void JSFSWatcher::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSFSWatcher::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSFSWatcherPrototype::create(vm, globalObject, JSFSWatcherPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue FSWatcher__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSFSWatcherStructure();
-    JSFSWatcher* instance = JSFSWatcher::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue FSWatcher__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSFSWatcherStructure();
+  JSFSWatcher* instance = JSFSWatcher::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -10934,7 +11734,7 @@ void JSFSWatcher::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSFSWatcher* thisObject = jsCast<JSFSWatcher*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -10943,17 +11743,17 @@ DEFINE_VISIT_CHILDREN(JSFSWatcher);
 template<typename Visitor>
 void JSFSWatcher::visitAdditionalChildren(Visitor& visitor)
 {
-    JSFSWatcher* thisObject = this;
+  JSFSWatcher* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_listener);
-
+    
     visitor.addOpaqueRoot(this->wrapped());
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSFSWatcher);
 
 template<typename Visitor>
-void JSFSWatcher::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSFSWatcher::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSFSWatcher* thisObject = jsCast<JSFSWatcher*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -10961,107 +11761,123 @@ void JSFSWatcher::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSFSWatcher);
-class JSFileSystemRouterPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSFileSystemRouterPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSFileSystemRouterPrototype* ptr = new (NotNull, JSC::allocateCell<JSFileSystemRouterPrototype>(vm)) JSFileSystemRouterPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFileSystemRouterPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSFileSystemRouterPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSFileSystemRouterPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSFileSystemRouterPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSFileSystemRouterPrototype* ptr = new (NotNull, JSC::allocateCell<JSFileSystemRouterPrototype>(vm)) JSFileSystemRouterPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFileSystemRouterPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSFileSystemRouterPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSFileSystemRouterConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSFileSystemRouterConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSFileSystemRouterPrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
+    public:
+        using Base = JSC::InternalFunction;
+        static JSFileSystemRouterConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSFileSystemRouterPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSFileSystemRouterConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForFileSystemRouterConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFileSystemRouterConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForFileSystemRouterConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForFileSystemRouterConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSFileSystemRouterPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSFileSystemRouterConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSFileSystemRouterPrototype* prototype);
+    };
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSFileSystemRouterConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForFileSystemRouterConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFileSystemRouterConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForFileSystemRouterConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForFileSystemRouterConstructor = std::forward<decltype(space)>(space); });
-    }
+extern "C" void* FileSystemRouterClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsFileSystemRouterConstructor);
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSFileSystemRouterPrototype* prototype);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSFileSystemRouterConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSFileSystemRouterPrototype* prototype);
-};
-
-extern "C" void* FileSystemRouterClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsFileSystemRouterConstructor);
 
 extern "C" void FileSystemRouterClass__finalize(void*);
 
+
 extern "C" EncodedJSValue FileSystemRouterPrototype__match(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(FileSystemRouterPrototype__matchCallback);
 
+
 extern "C" JSC::EncodedJSValue FileSystemRouterPrototype__getOrigin(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(FileSystemRouterPrototype__originGetterWrap);
 
+
 extern "C" EncodedJSValue FileSystemRouterPrototype__reload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(FileSystemRouterPrototype__reloadCallback);
 
+
 extern "C" JSC::EncodedJSValue FileSystemRouterPrototype__getRoutes(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(FileSystemRouterPrototype__routesGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue FileSystemRouterPrototype__getStyle(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(FileSystemRouterPrototype__styleGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSFileSystemRouterPrototype, JSFileSystemRouterPrototype::Base);
 
-static const HashTableValue JSFileSystemRouterPrototypeTableValues[] = {
-    { "match"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSystemRouterPrototype__matchCallback, 1 } },
-    { "origin"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, FileSystemRouterPrototype__originGetterWrap, 0 } },
-    { "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSystemRouterPrototype__reloadCallback, 0 } },
-    { "routes"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, FileSystemRouterPrototype__routesGetterWrap, 0 } },
-    { "style"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, FileSystemRouterPrototype__styleGetterWrap, 0 } }
+
+  static const HashTableValue JSFileSystemRouterPrototypeTableValues[] = {
+{ "match"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSystemRouterPrototype__matchCallback, 1 } }  ,
+{ "origin"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, FileSystemRouterPrototype__originGetterWrap, 0 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, FileSystemRouterPrototype__reloadCallback, 0 } }  ,
+{ "routes"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, FileSystemRouterPrototype__routesGetterWrap, 0 } }  ,
+{ "style"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, FileSystemRouterPrototype__styleGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSFileSystemRouterPrototype::s_info = { "FileSystemRouter"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFileSystemRouterPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsFileSystemRouterConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -11072,156 +11888,172 @@ JSC_DEFINE_CUSTOM_GETTER(jsFileSystemRouterConstructor, (JSGlobalObject * lexica
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for FileSystemRouter"_s);
     return JSValue::encode(globalObject->JSFileSystemRouterConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(FileSystemRouterPrototype__matchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSFileSystemRouter* thisObject = jsDynamicCast<JSFileSystemRouter*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(FileSystemRouterPrototype__matchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FileSystemRouter"_s);
-        return JSValue::encode({});
-    }
+        JSFileSystemRouter* thisObject = jsDynamicCast<JSFileSystemRouter*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FileSystemRouter"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    return FileSystemRouterPrototype__match(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return FileSystemRouterPrototype__match(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(FileSystemRouterPrototype__originGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSFileSystemRouter* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_origin.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        FileSystemRouterPrototype__getOrigin(thisObject->wrapped(), globalObject));
+        FileSystemRouterPrototype__getOrigin(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_origin.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void FileSystemRouterPrototype__originSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
-    thisObject->m_origin.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue FileSystemRouterPrototype__originGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void FileSystemRouterPrototype__originSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
+      thisObject->m_origin.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue FileSystemRouterPrototype__originGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_origin.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(FileSystemRouterPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(FileSystemRouterPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSFileSystemRouter* thisObject = jsDynamicCast<JSFileSystemRouter*>(callFrame->thisValue());
+        JSFileSystemRouter* thisObject = jsDynamicCast<JSFileSystemRouter*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FileSystemRouter"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof FileSystemRouter"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return FileSystemRouterPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return FileSystemRouterPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(FileSystemRouterPrototype__routesGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSFileSystemRouter* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_routes.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        FileSystemRouterPrototype__getRoutes(thisObject->wrapped(), globalObject));
+        FileSystemRouterPrototype__getRoutes(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_routes.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void FileSystemRouterPrototype__routesSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
-    thisObject->m_routes.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue FileSystemRouterPrototype__routesGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void FileSystemRouterPrototype__routesSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
+      thisObject->m_routes.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue FileSystemRouterPrototype__routesGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_routes.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(FileSystemRouterPrototype__styleGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSFileSystemRouter* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_style.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        FileSystemRouterPrototype__getStyle(thisObject->wrapped(), globalObject));
+        FileSystemRouterPrototype__getStyle(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_style.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void FileSystemRouterPrototype__styleSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
-    thisObject->m_style.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue FileSystemRouterPrototype__styleGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void FileSystemRouterPrototype__styleSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
+      thisObject->m_style.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue FileSystemRouterPrototype__styleGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSFileSystemRouter*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_style.get());
-}
+  }
+  
+  
 
 void JSFileSystemRouterPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -11233,64 +12065,67 @@ void JSFileSystemRouterPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObjec
 void JSFileSystemRouterConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSFileSystemRouterPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "FileSystemRouter"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSFileSystemRouterConstructor::JSFileSystemRouterConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSFileSystemRouterConstructor::JSFileSystemRouterConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSFileSystemRouterConstructor* JSFileSystemRouterConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSFileSystemRouterPrototype* prototype)
-{
+  }
+
+JSFileSystemRouterConstructor* JSFileSystemRouterConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSFileSystemRouterPrototype* prototype) {
     JSFileSystemRouterConstructor* ptr = new (NotNull, JSC::allocateCell<JSFileSystemRouterConstructor>(vm)) JSFileSystemRouterConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSFileSystemRouterConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSFileSystemRouterConstructor();
     Structure* structure = globalObject->JSFileSystemRouterStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSFileSystemRouterStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSFileSystemRouterStructure()
+      );
     }
 
     void* ptr = FileSystemRouterClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSFileSystemRouter* instance = JSFileSystemRouter::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSFileSystemRouterConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSFileSystemRouterPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSFileSystemRouterConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFileSystemRouterConstructor) };
 
-extern "C" EncodedJSValue FileSystemRouter__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue FileSystemRouter__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSFileSystemRouterConstructor());
-}
+  }
 
 JSFileSystemRouter::~JSFileSystemRouter()
 {
@@ -11302,7 +12137,7 @@ void JSFileSystemRouter::destroy(JSCell* cell)
 {
     static_cast<JSFileSystemRouter*>(cell)->JSFileSystemRouter::~JSFileSystemRouter();
 }
-
+  
 const ClassInfo JSFileSystemRouter::s_info = { "FileSystemRouter"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSFileSystemRouter) };
 
 void JSFileSystemRouter::finishCreation(VM& vm)
@@ -11311,38 +12146,37 @@ void JSFileSystemRouter::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSFileSystemRouter* JSFileSystemRouter::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSFileSystemRouter* ptr = new (NotNull, JSC::allocateCell<JSFileSystemRouter>(vm)) JSFileSystemRouter(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* FileSystemRouter__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSFileSystemRouter* JSFileSystemRouter::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSFileSystemRouter* ptr = new (NotNull, JSC::allocateCell<JSFileSystemRouter>(vm)) JSFileSystemRouter(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSFileSystemRouter* object = JSC::jsDynamicCast<JSFileSystemRouter*>(cell);
+extern "C" void* FileSystemRouter__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSFileSystemRouter* object = JSC::jsDynamicCast<JSFileSystemRouter*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool FileSystemRouter__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSFileSystemRouter* object = JSC::jsDynamicCast<JSFileSystemRouter*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool FileSystemRouter__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSFileSystemRouter* object = JSC::jsDynamicCast<JSFileSystemRouter*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t FileSystemRouter__ptrOffset = JSFileSystemRouter::offsetOfWrapped();
 
 void JSFileSystemRouter::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -11357,7 +12191,7 @@ void JSFileSystemRouter::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSFileSystemRouter::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSFileSystemRouterConstructor::create(vm, globalObject, WebCore::JSFileSystemRouterConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSFileSystemRouterPrototype*>(prototype));
+  return WebCore::JSFileSystemRouterConstructor::create(vm, globalObject, WebCore::JSFileSystemRouterConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSFileSystemRouterPrototype*>(prototype));
 }
 
 JSObject* JSFileSystemRouter::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -11365,13 +12199,12 @@ JSObject* JSFileSystemRouter::createPrototype(VM& vm, JSDOMGlobalObject* globalO
     return JSFileSystemRouterPrototype::create(vm, globalObject, JSFileSystemRouterPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue FileSystemRouter__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSFileSystemRouterStructure();
-    JSFileSystemRouter* instance = JSFileSystemRouter::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue FileSystemRouter__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSFileSystemRouterStructure();
+  JSFileSystemRouter* instance = JSFileSystemRouter::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -11380,7 +12213,7 @@ void JSFileSystemRouter::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSFileSystemRouter* thisObject = jsCast<JSFileSystemRouter*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -11389,18 +12222,19 @@ DEFINE_VISIT_CHILDREN(JSFileSystemRouter);
 template<typename Visitor>
 void JSFileSystemRouter::visitAdditionalChildren(Visitor& visitor)
 {
-    JSFileSystemRouter* thisObject = this;
+  JSFileSystemRouter* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_origin);
+    
+        visitor.append(thisObject->m_origin);
     visitor.append(thisObject->m_routes);
     visitor.append(thisObject->m_style);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSFileSystemRouter);
 
 template<typename Visitor>
-void JSFileSystemRouter::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSFileSystemRouter::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSFileSystemRouter* thisObject = jsCast<JSFileSystemRouter*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -11408,99 +12242,113 @@ void JSFileSystemRouter::visitOutputConstraintsImpl(JSCell* cell, Visitor& visit
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSFileSystemRouter);
-class JSHTMLRewriterPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSHTMLRewriterPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSHTMLRewriterPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTMLRewriterPrototype>(vm)) JSHTMLRewriterPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTMLRewriterPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSHTMLRewriterPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSHTMLRewriterPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSHTMLRewriterPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSHTMLRewriterPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTMLRewriterPrototype>(vm)) JSHTMLRewriterPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTMLRewriterPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSHTMLRewriterPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSHTMLRewriterConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSHTMLRewriterConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSHTMLRewriterPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSHTMLRewriterConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSHTMLRewriterPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSHTMLRewriterConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForHTMLRewriterConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHTMLRewriterConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForHTMLRewriterConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForHTMLRewriterConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSHTMLRewriterPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSHTMLRewriterConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSHTMLRewriterPrototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSHTMLRewriterConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForHTMLRewriterConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHTMLRewriterConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForHTMLRewriterConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForHTMLRewriterConstructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSHTMLRewriterPrototype* prototype);
+extern "C" void* HTMLRewriterClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsHTMLRewriterConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSHTMLRewriterConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSHTMLRewriterPrototype* prototype);
-};
 
-extern "C" void* HTMLRewriterClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsHTMLRewriterConstructor);
 
 extern "C" void HTMLRewriterClass__finalize(void*);
 
+
 extern "C" EncodedJSValue HTMLRewriterPrototype__on(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTMLRewriterPrototype__onCallback);
 
+
 extern "C" EncodedJSValue HTMLRewriterPrototype__onDocument(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTMLRewriterPrototype__onDocumentCallback);
 
+
 extern "C" EncodedJSValue HTMLRewriterPrototype__transform(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTMLRewriterPrototype__transformCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTMLRewriterPrototype, JSHTMLRewriterPrototype::Base);
 
-static const HashTableValue JSHTMLRewriterPrototypeTableValues[] = {
-    { "on"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTMLRewriterPrototype__onCallback, 2 } },
-    { "onDocument"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTMLRewriterPrototype__onDocumentCallback, 1 } },
-    { "transform"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTMLRewriterPrototype__transformCallback, 1 } }
+
+  static const HashTableValue JSHTMLRewriterPrototypeTableValues[] = {
+{ "on"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTMLRewriterPrototype__onCallback, 2 } }  ,
+{ "onDocument"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTMLRewriterPrototype__onDocumentCallback, 1 } }  ,
+{ "transform"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTMLRewriterPrototype__transformCallback, 1 } }
 };
 
+
+
 const ClassInfo JSHTMLRewriterPrototype::s_info = { "HTMLRewriter"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTMLRewriterPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsHTMLRewriterConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -11511,91 +12359,96 @@ JSC_DEFINE_CUSTOM_GETTER(jsHTMLRewriterConstructor, (JSGlobalObject * lexicalGlo
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for HTMLRewriter"_s);
     return JSValue::encode(globalObject->JSHTMLRewriterConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(HTMLRewriterPrototype__onCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSHTMLRewriter* thisObject = jsDynamicCast<JSHTMLRewriter*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(HTMLRewriterPrototype__onCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTMLRewriter"_s);
-        return JSValue::encode({});
-    }
+        JSHTMLRewriter* thisObject = jsDynamicCast<JSHTMLRewriter*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTMLRewriter"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return HTMLRewriterPrototype__on(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTMLRewriterPrototype__on(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTMLRewriterPrototype__onDocumentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTMLRewriterPrototype__onDocumentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTMLRewriter* thisObject = jsDynamicCast<JSHTMLRewriter*>(callFrame->thisValue());
 
-    JSHTMLRewriter* thisObject = jsDynamicCast<JSHTMLRewriter*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTMLRewriter"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTMLRewriter"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTMLRewriterPrototype__onDocument(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTMLRewriterPrototype__onDocument(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTMLRewriterPrototype__transformCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTMLRewriterPrototype__transformCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTMLRewriter* thisObject = jsDynamicCast<JSHTMLRewriter*>(callFrame->thisValue());
 
-    JSHTMLRewriter* thisObject = jsDynamicCast<JSHTMLRewriter*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTMLRewriter"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTMLRewriter"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTMLRewriterPrototype__transform(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return HTMLRewriterPrototype__transform(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSHTMLRewriterPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -11607,64 +12460,67 @@ void JSHTMLRewriterPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* g
 void JSHTMLRewriterConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSHTMLRewriterPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "HTMLRewriter"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSHTMLRewriterConstructor::JSHTMLRewriterConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSHTMLRewriterConstructor::JSHTMLRewriterConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSHTMLRewriterConstructor* JSHTMLRewriterConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSHTMLRewriterPrototype* prototype)
-{
+  }
+
+JSHTMLRewriterConstructor* JSHTMLRewriterConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSHTMLRewriterPrototype* prototype) {
     JSHTMLRewriterConstructor* ptr = new (NotNull, JSC::allocateCell<JSHTMLRewriterConstructor>(vm)) JSHTMLRewriterConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSHTMLRewriterConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSHTMLRewriterConstructor();
     Structure* structure = globalObject->JSHTMLRewriterStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSHTMLRewriterStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSHTMLRewriterStructure()
+      );
     }
 
     void* ptr = HTMLRewriterClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSHTMLRewriter* instance = JSHTMLRewriter::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSHTMLRewriterConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSHTMLRewriterPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSHTMLRewriterConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTMLRewriterConstructor) };
 
-extern "C" EncodedJSValue HTMLRewriter__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue HTMLRewriter__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSHTMLRewriterConstructor());
-}
+  }
 
 JSHTMLRewriter::~JSHTMLRewriter()
 {
@@ -11676,7 +12532,7 @@ void JSHTMLRewriter::destroy(JSCell* cell)
 {
     static_cast<JSHTMLRewriter*>(cell)->JSHTMLRewriter::~JSHTMLRewriter();
 }
-
+  
 const ClassInfo JSHTMLRewriter::s_info = { "HTMLRewriter"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTMLRewriter) };
 
 void JSHTMLRewriter::finishCreation(VM& vm)
@@ -11685,38 +12541,37 @@ void JSHTMLRewriter::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSHTMLRewriter* JSHTMLRewriter::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSHTMLRewriter* ptr = new (NotNull, JSC::allocateCell<JSHTMLRewriter>(vm)) JSHTMLRewriter(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* HTMLRewriter__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSHTMLRewriter* JSHTMLRewriter::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSHTMLRewriter* ptr = new (NotNull, JSC::allocateCell<JSHTMLRewriter>(vm)) JSHTMLRewriter(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSHTMLRewriter* object = JSC::jsDynamicCast<JSHTMLRewriter*>(cell);
+extern "C" void* HTMLRewriter__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSHTMLRewriter* object = JSC::jsDynamicCast<JSHTMLRewriter*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool HTMLRewriter__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSHTMLRewriter* object = JSC::jsDynamicCast<JSHTMLRewriter*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool HTMLRewriter__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSHTMLRewriter* object = JSC::jsDynamicCast<JSHTMLRewriter*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t HTMLRewriter__ptrOffset = JSHTMLRewriter::offsetOfWrapped();
 
 void JSHTMLRewriter::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -11731,7 +12586,7 @@ void JSHTMLRewriter::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSHTMLRewriter::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSHTMLRewriterConstructor::create(vm, globalObject, WebCore::JSHTMLRewriterConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSHTMLRewriterPrototype*>(prototype));
+  return WebCore::JSHTMLRewriterConstructor::create(vm, globalObject, WebCore::JSHTMLRewriterConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSHTMLRewriterPrototype*>(prototype));
 }
 
 JSObject* JSHTMLRewriter::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -11739,114 +12594,137 @@ JSObject* JSHTMLRewriter::createPrototype(VM& vm, JSDOMGlobalObject* globalObjec
     return JSHTMLRewriterPrototype::create(vm, globalObject, JSHTMLRewriterPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue HTMLRewriter__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSHTMLRewriterStructure();
-    JSHTMLRewriter* instance = JSHTMLRewriter::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSHTTPSServerPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+extern "C" EncodedJSValue HTMLRewriter__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSHTMLRewriterStructure();
+  JSHTMLRewriter* instance = JSHTMLRewriter::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSHTTPSServerPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSHTTPSServerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSHTTPSServerPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTTPSServerPrototype>(vm)) JSHTTPSServerPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPSServerPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSHTTPSServerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSHTTPSServerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSHTTPSServerPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTTPSServerPrototype>(vm)) JSHTTPSServerPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* HTTPSServerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsHTTPSServerConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPSServerPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSHTTPSServerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* HTTPSServerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsHTTPSServerConstructor);
 
 extern "C" void HTTPSServerClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue HTTPSServerPrototype__getAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPSServerPrototype__addressGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPSServerPrototype__getDevelopment(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPSServerPrototype__developmentGetterWrap);
 
+
 extern "C" EncodedJSValue HTTPSServerPrototype__doFetch(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPSServerPrototype__fetchCallback);
 
+
 extern "C" JSC::EncodedJSValue HTTPSServerPrototype__getHostname(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPSServerPrototype__hostnameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPSServerPrototype__getId(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPSServerPrototype__idGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPSServerPrototype__getPendingRequests(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPSServerPrototype__pendingRequestsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPSServerPrototype__getPendingWebSockets(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPSServerPrototype__pendingWebSocketsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPSServerPrototype__getPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPSServerPrototype__portGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPSServerPrototype__getProtocol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPSServerPrototype__protocolGetterWrap);
 
+
 extern "C" EncodedJSValue HTTPSServerPrototype__doPublish(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPSServerPrototype__publishCallback);
 
+
 extern "C" EncodedJSValue HTTPSServerPrototype__doReload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPSServerPrototype__reloadCallback);
 
+
 extern "C" EncodedJSValue HTTPSServerPrototype__doRequestIP(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPSServerPrototype__requestIPCallback);
 
+
 extern "C" EncodedJSValue HTTPSServerPrototype__doStop(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPSServerPrototype__stopCallback);
 
+
 extern "C" EncodedJSValue HTTPSServerPrototype__doUpgrade(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPSServerPrototype__upgradeCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPSServerPrototype, JSHTTPSServerPrototype::Base);
 
-static const HashTableValue JSHTTPSServerPrototypeTableValues[] = {
-    { "address"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__addressGetterWrap, 0 } },
-    { "development"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__developmentGetterWrap, 0 } },
-    { "fetch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__fetchCallback, 1 } },
-    { "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__hostnameGetterWrap, 0 } },
-    { "id"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__idGetterWrap, 0 } },
-    { "pendingRequests"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__pendingRequestsGetterWrap, 0 } },
-    { "pendingWebSockets"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__pendingWebSocketsGetterWrap, 0 } },
-    { "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__portGetterWrap, 0 } },
-    { "protocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__protocolGetterWrap, 0 } },
-    { "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__publishCallback, 3 } },
-    { "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__reloadCallback, 2 } },
-    { "requestIP"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__requestIPCallback, 1 } },
-    { "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__stopCallback, 1 } },
-    { "upgrade"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__upgradeCallback, 1 } }
+
+  static const HashTableValue JSHTTPSServerPrototypeTableValues[] = {
+{ "address"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__addressGetterWrap, 0 } }  ,
+{ "development"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__developmentGetterWrap, 0 } }  ,
+{ "fetch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__fetchCallback, 1 } }  ,
+{ "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__hostnameGetterWrap, 0 } }  ,
+{ "id"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__idGetterWrap, 0 } }  ,
+{ "pendingRequests"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__pendingRequestsGetterWrap, 0 } }  ,
+{ "pendingWebSockets"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__pendingWebSocketsGetterWrap, 0 } }  ,
+{ "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__portGetterWrap, 0 } }  ,
+{ "protocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPSServerPrototype__protocolGetterWrap, 0 } }  ,
+{ "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__publishCallback, 3 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__reloadCallback, 2 } }  ,
+{ "requestIP"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__requestIPCallback, 1 } }  ,
+{ "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__stopCallback, 1 } }  ,
+{ "upgrade"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPSServerPrototype__upgradeCallback, 1 } }
 };
 
+
+
 const ClassInfo JSHTTPSServerPrototype::s_info = { "HTTPSServer"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPSServerPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsHTTPSServerConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -11857,43 +12735,49 @@ JSC_DEFINE_CUSTOM_GETTER(jsHTTPSServerConstructor, (JSGlobalObject * lexicalGlob
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for HTTPSServer"_s);
     return JSValue::encode(globalObject->JSHTTPSServerConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__addressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_address.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        HTTPSServerPrototype__getAddress(thisObject->wrapped(), globalObject));
+        HTTPSServerPrototype__getAddress(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_address.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void HTTPSServerPrototype__addressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
-    thisObject->m_address.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue HTTPSServerPrototype__addressGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void HTTPSServerPrototype__addressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
+      thisObject->m_address.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue HTTPSServerPrototype__addressGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_address.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__developmentGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -11901,101 +12785,111 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__developmentGetterWrap, (JSGlobalO
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__fetchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__fetchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
+        JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return HTTPSServerPrototype__doFetch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return HTTPSServerPrototype__doFetch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__hostnameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_hostname.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        HTTPSServerPrototype__getHostname(thisObject->wrapped(), globalObject));
+        HTTPSServerPrototype__getHostname(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_hostname.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void HTTPSServerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
-    thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue HTTPSServerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void HTTPSServerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
+      thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue HTTPSServerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_hostname.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__idGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_id.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        HTTPSServerPrototype__getId(thisObject->wrapped(), globalObject));
+        HTTPSServerPrototype__getId(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_id.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void HTTPSServerPrototype__idSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
-    thisObject->m_id.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue HTTPSServerPrototype__idGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void HTTPSServerPrototype__idSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
+      thisObject->m_id.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue HTTPSServerPrototype__idGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_id.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__pendingRequestsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12003,11 +12897,12 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__pendingRequestsGetterWrap, (JSGlo
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__pendingWebSocketsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12015,11 +12910,12 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__pendingWebSocketsGetterWrap, (JSG
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__portGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12027,11 +12923,12 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__portGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__protocolGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12039,146 +12936,152 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPSServerPrototype__protocolGetterWrap, (JSGlobalObje
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
+        JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return HTTPSServerPrototype__doPublish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTTPSServerPrototype__doPublish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
 
-    JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPSServerPrototype__doReload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTTPSServerPrototype__doReload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__requestIPCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__requestIPCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
 
-    JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPSServerPrototype__doRequestIP(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTTPSServerPrototype__doRequestIP(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
 
-    JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPSServerPrototype__doStop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTTPSServerPrototype__doStop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__upgradeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTTPSServerPrototype__upgradeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
 
-    JSHTTPSServer* thisObject = jsDynamicCast<JSHTTPSServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPSServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPSServerPrototype__doUpgrade(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return HTTPSServerPrototype__doUpgrade(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSHTTPSServerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -12197,7 +13100,7 @@ void JSHTTPSServer::destroy(JSCell* cell)
 {
     static_cast<JSHTTPSServer*>(cell)->JSHTTPSServer::~JSHTTPSServer();
 }
-
+  
 const ClassInfo JSHTTPSServer::s_info = { "HTTPSServer"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPSServer) };
 
 void JSHTTPSServer::finishCreation(VM& vm)
@@ -12206,38 +13109,37 @@ void JSHTTPSServer::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSHTTPSServer* JSHTTPSServer::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSHTTPSServer* ptr = new (NotNull, JSC::allocateCell<JSHTTPSServer>(vm)) JSHTTPSServer(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* HTTPSServer__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSHTTPSServer* JSHTTPSServer::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSHTTPSServer* ptr = new (NotNull, JSC::allocateCell<JSHTTPSServer>(vm)) JSHTTPSServer(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSHTTPSServer* object = JSC::jsDynamicCast<JSHTTPSServer*>(cell);
+extern "C" void* HTTPSServer__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSHTTPSServer* object = JSC::jsDynamicCast<JSHTTPSServer*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool HTTPSServer__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSHTTPSServer* object = JSC::jsDynamicCast<JSHTTPSServer*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool HTTPSServer__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSHTTPSServer* object = JSC::jsDynamicCast<JSHTTPSServer*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t HTTPSServer__ptrOffset = JSHTTPSServer::offsetOfWrapped();
 
 void JSHTTPSServer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -12250,18 +13152,19 @@ void JSHTTPSServer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSHTTPSServer::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSHTTPSServerPrototype::create(vm, globalObject, JSHTTPSServerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue HTTPSServer__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSHTTPSServerStructure();
-    JSHTTPSServer* instance = JSHTTPSServer::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue HTTPSServer__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSHTTPSServerStructure();
+  JSHTTPSServer* instance = JSHTTPSServer::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -12270,7 +13173,7 @@ void JSHTTPSServer::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -12279,18 +13182,19 @@ DEFINE_VISIT_CHILDREN(JSHTTPSServer);
 template<typename Visitor>
 void JSHTTPSServer::visitAdditionalChildren(Visitor& visitor)
 {
-    JSHTTPSServer* thisObject = this;
+  JSHTTPSServer* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_address);
+    
+        visitor.append(thisObject->m_address);
     visitor.append(thisObject->m_hostname);
     visitor.append(thisObject->m_id);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSHTTPSServer);
 
 template<typename Visitor>
-void JSHTTPSServer::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSHTTPSServer::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSHTTPSServer* thisObject = jsCast<JSHTTPSServer*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -12298,106 +13202,130 @@ void JSHTTPSServer::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSHTTPSServer);
-class JSHTTPServerPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSHTTPServerPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSHTTPServerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSHTTPServerPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTTPServerPrototype>(vm)) JSHTTPServerPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPServerPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSHTTPServerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSHTTPServerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSHTTPServerPrototype* ptr = new (NotNull, JSC::allocateCell<JSHTTPServerPrototype>(vm)) JSHTTPServerPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* HTTPServerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsHTTPServerConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPServerPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSHTTPServerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* HTTPServerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsHTTPServerConstructor);
 
 extern "C" void HTTPServerClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue HTTPServerPrototype__getAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPServerPrototype__addressGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPServerPrototype__getDevelopment(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPServerPrototype__developmentGetterWrap);
 
+
 extern "C" EncodedJSValue HTTPServerPrototype__doFetch(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPServerPrototype__fetchCallback);
 
+
 extern "C" JSC::EncodedJSValue HTTPServerPrototype__getHostname(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPServerPrototype__hostnameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPServerPrototype__getId(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPServerPrototype__idGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPServerPrototype__getPendingRequests(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPServerPrototype__pendingRequestsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPServerPrototype__getPendingWebSockets(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPServerPrototype__pendingWebSocketsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPServerPrototype__getPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPServerPrototype__portGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue HTTPServerPrototype__getProtocol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(HTTPServerPrototype__protocolGetterWrap);
 
+
 extern "C" EncodedJSValue HTTPServerPrototype__doPublish(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPServerPrototype__publishCallback);
 
+
 extern "C" EncodedJSValue HTTPServerPrototype__doReload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPServerPrototype__reloadCallback);
 
+
 extern "C" EncodedJSValue HTTPServerPrototype__doRequestIP(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPServerPrototype__requestIPCallback);
 
+
 extern "C" EncodedJSValue HTTPServerPrototype__doStop(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPServerPrototype__stopCallback);
 
+
 extern "C" EncodedJSValue HTTPServerPrototype__doUpgrade(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(HTTPServerPrototype__upgradeCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSHTTPServerPrototype, JSHTTPServerPrototype::Base);
 
-static const HashTableValue JSHTTPServerPrototypeTableValues[] = {
-    { "address"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__addressGetterWrap, 0 } },
-    { "development"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__developmentGetterWrap, 0 } },
-    { "fetch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__fetchCallback, 1 } },
-    { "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__hostnameGetterWrap, 0 } },
-    { "id"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__idGetterWrap, 0 } },
-    { "pendingRequests"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__pendingRequestsGetterWrap, 0 } },
-    { "pendingWebSockets"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__pendingWebSocketsGetterWrap, 0 } },
-    { "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__portGetterWrap, 0 } },
-    { "protocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__protocolGetterWrap, 0 } },
-    { "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__publishCallback, 3 } },
-    { "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__reloadCallback, 2 } },
-    { "requestIP"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__requestIPCallback, 1 } },
-    { "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__stopCallback, 1 } },
-    { "upgrade"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__upgradeCallback, 1 } }
+
+  static const HashTableValue JSHTTPServerPrototypeTableValues[] = {
+{ "address"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__addressGetterWrap, 0 } }  ,
+{ "development"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__developmentGetterWrap, 0 } }  ,
+{ "fetch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__fetchCallback, 1 } }  ,
+{ "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__hostnameGetterWrap, 0 } }  ,
+{ "id"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__idGetterWrap, 0 } }  ,
+{ "pendingRequests"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__pendingRequestsGetterWrap, 0 } }  ,
+{ "pendingWebSockets"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__pendingWebSocketsGetterWrap, 0 } }  ,
+{ "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__portGetterWrap, 0 } }  ,
+{ "protocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, HTTPServerPrototype__protocolGetterWrap, 0 } }  ,
+{ "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__publishCallback, 3 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__reloadCallback, 2 } }  ,
+{ "requestIP"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__requestIPCallback, 1 } }  ,
+{ "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__stopCallback, 1 } }  ,
+{ "upgrade"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, HTTPServerPrototype__upgradeCallback, 1 } }
 };
 
+
+
 const ClassInfo JSHTTPServerPrototype::s_info = { "HTTPServer"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPServerPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsHTTPServerConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -12408,43 +13336,49 @@ JSC_DEFINE_CUSTOM_GETTER(jsHTTPServerConstructor, (JSGlobalObject * lexicalGloba
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for HTTPServer"_s);
     return JSValue::encode(globalObject->JSHTTPServerConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__addressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_address.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        HTTPServerPrototype__getAddress(thisObject->wrapped(), globalObject));
+        HTTPServerPrototype__getAddress(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_address.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void HTTPServerPrototype__addressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
-    thisObject->m_address.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue HTTPServerPrototype__addressGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void HTTPServerPrototype__addressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
+      thisObject->m_address.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue HTTPServerPrototype__addressGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_address.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__developmentGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12452,101 +13386,111 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__developmentGetterWrap, (JSGlobalOb
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__fetchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__fetchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
+        JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return HTTPServerPrototype__doFetch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return HTTPServerPrototype__doFetch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__hostnameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_hostname.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        HTTPServerPrototype__getHostname(thisObject->wrapped(), globalObject));
+        HTTPServerPrototype__getHostname(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_hostname.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void HTTPServerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
-    thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue HTTPServerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void HTTPServerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
+      thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue HTTPServerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_hostname.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__idGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_id.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        HTTPServerPrototype__getId(thisObject->wrapped(), globalObject));
+        HTTPServerPrototype__getId(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_id.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void HTTPServerPrototype__idSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
-    thisObject->m_id.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue HTTPServerPrototype__idGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void HTTPServerPrototype__idSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
+      thisObject->m_id.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue HTTPServerPrototype__idGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_id.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__pendingRequestsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12554,11 +13498,12 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__pendingRequestsGetterWrap, (JSGlob
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__pendingWebSocketsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12566,11 +13511,12 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__pendingWebSocketsGetterWrap, (JSGl
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__portGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12578,11 +13524,12 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__portGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__protocolGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12590,146 +13537,152 @@ JSC_DEFINE_CUSTOM_GETTER(HTTPServerPrototype__protocolGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
+        JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPServerPrototype__doPublish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTTPServerPrototype__doPublish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
 
-    JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPServerPrototype__doReload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTTPServerPrototype__doReload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__requestIPCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__requestIPCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
 
-    JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPServerPrototype__doRequestIP(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTTPServerPrototype__doRequestIP(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
 
-    JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPServerPrototype__doStop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return HTTPServerPrototype__doStop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__upgradeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(HTTPServerPrototype__upgradeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
 
-    JSHTTPServer* thisObject = jsDynamicCast<JSHTTPServer*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof HTTPServer"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return HTTPServerPrototype__doUpgrade(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return HTTPServerPrototype__doUpgrade(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSHTTPServerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -12748,7 +13701,7 @@ void JSHTTPServer::destroy(JSCell* cell)
 {
     static_cast<JSHTTPServer*>(cell)->JSHTTPServer::~JSHTTPServer();
 }
-
+  
 const ClassInfo JSHTTPServer::s_info = { "HTTPServer"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSHTTPServer) };
 
 void JSHTTPServer::finishCreation(VM& vm)
@@ -12757,38 +13710,37 @@ void JSHTTPServer::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSHTTPServer* JSHTTPServer::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSHTTPServer* ptr = new (NotNull, JSC::allocateCell<JSHTTPServer>(vm)) JSHTTPServer(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* HTTPServer__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSHTTPServer* JSHTTPServer::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSHTTPServer* ptr = new (NotNull, JSC::allocateCell<JSHTTPServer>(vm)) JSHTTPServer(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSHTTPServer* object = JSC::jsDynamicCast<JSHTTPServer*>(cell);
+extern "C" void* HTTPServer__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSHTTPServer* object = JSC::jsDynamicCast<JSHTTPServer*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool HTTPServer__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSHTTPServer* object = JSC::jsDynamicCast<JSHTTPServer*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool HTTPServer__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSHTTPServer* object = JSC::jsDynamicCast<JSHTTPServer*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t HTTPServer__ptrOffset = JSHTTPServer::offsetOfWrapped();
 
 void JSHTTPServer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -12801,18 +13753,19 @@ void JSHTTPServer::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSHTTPServer::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSHTTPServerPrototype::create(vm, globalObject, JSHTTPServerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue HTTPServer__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSHTTPServerStructure();
-    JSHTTPServer* instance = JSHTTPServer::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue HTTPServer__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSHTTPServerStructure();
+  JSHTTPServer* instance = JSHTTPServer::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -12821,7 +13774,7 @@ void JSHTTPServer::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -12830,18 +13783,19 @@ DEFINE_VISIT_CHILDREN(JSHTTPServer);
 template<typename Visitor>
 void JSHTTPServer::visitAdditionalChildren(Visitor& visitor)
 {
-    JSHTTPServer* thisObject = this;
+  JSHTTPServer* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_address);
+    
+        visitor.append(thisObject->m_address);
     visitor.append(thisObject->m_hostname);
     visitor.append(thisObject->m_id);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSHTTPServer);
 
 template<typename Visitor>
-void JSHTTPServer::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSHTTPServer::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSHTTPServer* thisObject = jsCast<JSHTTPServer*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -12849,85 +13803,104 @@ void JSHTTPServer::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSHTTPServer);
-class JSListenerPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSListenerPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSListenerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSListenerPrototype* ptr = new (NotNull, JSC::allocateCell<JSListenerPrototype>(vm)) JSListenerPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSListenerPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSListenerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSListenerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSListenerPrototype* ptr = new (NotNull, JSC::allocateCell<JSListenerPrototype>(vm)) JSListenerPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* ListenerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsListenerConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSListenerPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSListenerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* ListenerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsListenerConstructor);
 
 extern "C" void ListenerClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue ListenerPrototype__getData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ListenerPrototype__dataGetterWrap);
 
+
 extern "C" bool ListenerPrototype__setData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
 JSC_DECLARE_CUSTOM_SETTER(ListenerPrototype__dataSetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ListenerPrototype__getHostname(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ListenerPrototype__hostnameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ListenerPrototype__getPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ListenerPrototype__portGetterWrap);
 
+
 extern "C" EncodedJSValue ListenerPrototype__ref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ListenerPrototype__refCallback);
 
+
 extern "C" EncodedJSValue ListenerPrototype__reload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ListenerPrototype__reloadCallback);
 
+
 extern "C" EncodedJSValue ListenerPrototype__stop(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ListenerPrototype__stopCallback);
 
+
 extern "C" JSC::EncodedJSValue ListenerPrototype__getUnix(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ListenerPrototype__unixGetterWrap);
 
+
 extern "C" EncodedJSValue ListenerPrototype__unref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ListenerPrototype__unrefCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSListenerPrototype, JSListenerPrototype::Base);
 
-static const HashTableValue JSListenerPrototypeTableValues[] = {
-    { "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__dataGetterWrap, ListenerPrototype__dataSetterWrap } },
-    { "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__hostnameGetterWrap, 0 } },
-    { "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__portGetterWrap, 0 } },
-    { "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__refCallback, 0 } },
-    { "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__reloadCallback, 1 } },
-    { "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__stopCallback, 1 } },
-    { "unix"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__unixGetterWrap, 0 } },
-    { "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__unrefCallback, 0 } }
+
+  static const HashTableValue JSListenerPrototypeTableValues[] = {
+{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__dataGetterWrap, ListenerPrototype__dataSetterWrap } }  ,
+{ "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__hostnameGetterWrap, 0 } }  ,
+{ "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__portGetterWrap, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__refCallback, 0 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__reloadCallback, 1 } }  ,
+{ "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__stopCallback, 1 } }  ,
+{ "unix"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__unixGetterWrap, 0 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__unrefCallback, 0 } }
 };
 
+
+
 const ClassInfo JSListenerPrototype::s_info = { "Listener"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSListenerPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsListenerConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -12938,12 +13911,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsListenerConstructor, (JSGlobalObject * lexicalGlobalO
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Listener"_s);
     return JSValue::encode(globalObject->JSListenerConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__dataGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -12951,6 +13926,7 @@ JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__dataGetterWrap, (JSGlobalObject * le
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_SETTER(ListenerPrototype__dataSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
 {
@@ -12963,41 +13939,46 @@ JSC_DEFINE_CUSTOM_SETTER(ListenerPrototype__dataSetterWrap, (JSGlobalObject * le
     RELEASE_AND_RETURN(throwScope, result);
 }
 
+
 JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__hostnameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_hostname.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ListenerPrototype__getHostname(thisObject->wrapped(), globalObject));
+        ListenerPrototype__getHostname(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_hostname.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ListenerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
-    thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ListenerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ListenerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+      thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ListenerPrototype__hostnameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_hostname.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__portGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -13005,149 +13986,158 @@ JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__portGetterWrap, (JSGlobalObject * le
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
+        JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Listener"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Listener"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return ListenerPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ListenerPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
 
-    JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Listener"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Listener"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ListenerPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ListenerPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
 
-    JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Listener"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Listener"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ListenerPrototype__stop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ListenerPrototype__stop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__unixGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_unix.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ListenerPrototype__getUnix(thisObject->wrapped(), globalObject));
+        ListenerPrototype__getUnix(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_unix.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ListenerPrototype__unixSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
-    thisObject->m_unix.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ListenerPrototype__unixGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ListenerPrototype__unixSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+      thisObject->m_unix.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ListenerPrototype__unixGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_unix.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
+        JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Listener"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Listener"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return ListenerPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return ListenerPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 void JSListenerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -13166,7 +14156,7 @@ void JSListener::destroy(JSCell* cell)
 {
     static_cast<JSListener*>(cell)->JSListener::~JSListener();
 }
-
+  
 const ClassInfo JSListener::s_info = { "Listener"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSListener) };
 
 void JSListener::finishCreation(VM& vm)
@@ -13175,38 +14165,37 @@ void JSListener::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSListener* JSListener::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSListener* ptr = new (NotNull, JSC::allocateCell<JSListener>(vm)) JSListener(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Listener__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSListener* JSListener::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSListener* ptr = new (NotNull, JSC::allocateCell<JSListener>(vm)) JSListener(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSListener* object = JSC::jsDynamicCast<JSListener*>(cell);
+extern "C" void* Listener__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSListener* object = JSC::jsDynamicCast<JSListener*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Listener__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSListener* object = JSC::jsDynamicCast<JSListener*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Listener__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSListener* object = JSC::jsDynamicCast<JSListener*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Listener__ptrOffset = JSListener::offsetOfWrapped();
 
 void JSListener::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -13219,18 +14208,19 @@ void JSListener::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSListener::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSListenerPrototype::create(vm, globalObject, JSListenerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Listener__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSListenerStructure();
-    JSListener* instance = JSListener::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Listener__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSListenerStructure();
+  JSListener* instance = JSListener::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -13239,7 +14229,7 @@ void JSListener::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSListener* thisObject = jsCast<JSListener*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -13248,17 +14238,18 @@ DEFINE_VISIT_CHILDREN(JSListener);
 template<typename Visitor>
 void JSListener::visitAdditionalChildren(Visitor& visitor)
 {
-    JSListener* thisObject = this;
+  JSListener* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_hostname);
+    
+        visitor.append(thisObject->m_hostname);
     visitor.append(thisObject->m_unix);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSListener);
 
 template<typename Visitor>
-void JSListener::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSListener::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSListener* thisObject = jsCast<JSListener*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -13266,99 +14257,113 @@ void JSListener::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSListener);
-class JSMD4Prototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSMD4Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSMD4Prototype* ptr = new (NotNull, JSC::allocateCell<JSMD4Prototype>(vm)) JSMD4Prototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMD4Prototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSMD4Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSMD4Prototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSMD4Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSMD4Prototype* ptr = new (NotNull, JSC::allocateCell<JSMD4Prototype>(vm)) JSMD4Prototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMD4Prototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSMD4Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSMD4Constructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSMD4Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSMD4Prototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
+    public:
+        using Base = JSC::InternalFunction;
+        static JSMD4Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSMD4Prototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSMD4Constructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForMD4Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD4Constructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForMD4Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForMD4Constructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSMD4Prototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSMD4Constructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSMD4Prototype* prototype);
+    };
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSMD4Constructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForMD4Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD4Constructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForMD4Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForMD4Constructor = std::forward<decltype(space)>(space); });
-    }
+extern "C" void* MD4Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsMD4Constructor);
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSMD4Prototype* prototype);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSMD4Constructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSMD4Prototype* prototype);
-};
-
-extern "C" void* MD4Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsMD4Constructor);
 
 extern "C" void MD4Class__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue MD4Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MD4Prototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue MD4Prototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(MD4Prototype__digestCallback);
 
+
 extern "C" EncodedJSValue MD4Prototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(MD4Prototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMD4Prototype, JSMD4Prototype::Base);
 
-static const HashTableValue JSMD4PrototypeTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MD4Prototype__byteLengthGetterWrap, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD4Prototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD4Prototype__updateCallback, 1 } }
+
+  static const HashTableValue JSMD4PrototypeTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MD4Prototype__byteLengthGetterWrap, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD4Prototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD4Prototype__updateCallback, 1 } }
 };
 
+
+
 const ClassInfo JSMD4Prototype::s_info = { "MD4"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMD4Prototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsMD4Constructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -13369,12 +14374,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsMD4Constructor, (JSGlobalObject * lexicalGlobalObject
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for MD4"_s);
     return JSValue::encode(globalObject->JSMD4Constructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(MD4Prototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMD4* thisObject = jsCast<JSMD4*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -13382,62 +14389,65 @@ JSC_DEFINE_CUSTOM_GETTER(MD4Prototype__byteLengthGetterWrap, (JSGlobalObject * l
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(MD4Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(MD4Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSMD4* thisObject = jsDynamicCast<JSMD4*>(callFrame->thisValue());
+        JSMD4* thisObject = jsDynamicCast<JSMD4*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof MD4"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof MD4"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return MD4Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return MD4Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(MD4Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(MD4Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSMD4* thisObject = jsDynamicCast<JSMD4*>(callFrame->thisValue());
 
-    JSMD4* thisObject = jsDynamicCast<JSMD4*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof MD4"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof MD4"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return MD4Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return MD4Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSMD4Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -13449,11 +14459,12 @@ void JSMD4Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObje
 extern "C" JSC_DECLARE_CUSTOM_GETTER(MD4Class__getByteLengthStatic);
 extern "C" JSC_DECLARE_HOST_FUNCTION(MD4Class__hash);
 
-static const HashTableValue JSMD4ConstructorTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MD4Class__getByteLengthStatic, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD4Class__hash, 2 } }
+  static const HashTableValue JSMD4ConstructorTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MD4Class__getByteLengthStatic, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD4Class__hash, 2 } }
 };
 
+
 void JSMD4Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSMD4Prototype* prototype)
 {
     Base::finishCreation(vm, 0, "MD4"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -13462,59 +14473,62 @@ void JSMD4Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject,
     ASSERT(inherits(info()));
 }
 
-JSMD4Constructor::JSMD4Constructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSMD4Constructor::JSMD4Constructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSMD4Constructor* JSMD4Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSMD4Prototype* prototype)
-{
+  }
+
+JSMD4Constructor* JSMD4Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSMD4Prototype* prototype) {
     JSMD4Constructor* ptr = new (NotNull, JSC::allocateCell<JSMD4Constructor>(vm)) JSMD4Constructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSMD4Constructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSMD4Constructor();
     Structure* structure = globalObject->JSMD4Structure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSMD4Structure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSMD4Structure()
+      );
     }
 
     void* ptr = MD4Class__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSMD4* instance = JSMD4::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSMD4Constructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSMD4Prototype* prototype)
 {
+
 }
 
 const ClassInfo JSMD4Constructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMD4Constructor) };
 
-extern "C" EncodedJSValue MD4__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue MD4__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSMD4Constructor());
-}
+  }
 
 JSMD4::~JSMD4()
 {
@@ -13526,7 +14540,7 @@ void JSMD4::destroy(JSCell* cell)
 {
     static_cast<JSMD4*>(cell)->JSMD4::~JSMD4();
 }
-
+  
 const ClassInfo JSMD4::s_info = { "MD4"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMD4) };
 
 void JSMD4::finishCreation(VM& vm)
@@ -13535,38 +14549,37 @@ void JSMD4::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSMD4* JSMD4::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSMD4* ptr = new (NotNull, JSC::allocateCell<JSMD4>(vm)) JSMD4(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* MD4__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSMD4* JSMD4::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSMD4* ptr = new (NotNull, JSC::allocateCell<JSMD4>(vm)) JSMD4(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSMD4* object = JSC::jsDynamicCast<JSMD4*>(cell);
+extern "C" void* MD4__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSMD4* object = JSC::jsDynamicCast<JSMD4*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool MD4__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSMD4* object = JSC::jsDynamicCast<JSMD4*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool MD4__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSMD4* object = JSC::jsDynamicCast<JSMD4*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t MD4__ptrOffset = JSMD4::offsetOfWrapped();
 
 void JSMD4::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -13581,7 +14594,7 @@ void JSMD4::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSMD4::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSMD4Constructor::create(vm, globalObject, WebCore::JSMD4Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSMD4Prototype*>(prototype));
+  return WebCore::JSMD4Constructor::create(vm, globalObject, WebCore::JSMD4Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSMD4Prototype*>(prototype));
 }
 
 JSObject* JSMD4::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -13589,107 +14602,120 @@ JSObject* JSMD4::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSMD4Prototype::create(vm, globalObject, JSMD4Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue MD4__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSMD4Structure();
-    JSMD4* instance = JSMD4::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSMD5Prototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSMD5Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSMD5Prototype* ptr = new (NotNull, JSC::allocateCell<JSMD5Prototype>(vm)) JSMD5Prototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMD5Prototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSMD5Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue MD4__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSMD4Structure();
+  JSMD4* instance = JSMD4::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSMD5Prototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSMD5Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSMD5Prototype* ptr = new (NotNull, JSC::allocateCell<JSMD5Prototype>(vm)) JSMD5Prototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMD5Prototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSMD5Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSMD5Constructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSMD5Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSMD5Prototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSMD5Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSMD5Prototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSMD5Constructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForMD5Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD5Constructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForMD5Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForMD5Constructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSMD5Prototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSMD5Constructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSMD5Prototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSMD5Constructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForMD5Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD5Constructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForMD5Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForMD5Constructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSMD5Prototype* prototype);
+extern "C" void* MD5Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsMD5Constructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSMD5Constructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSMD5Prototype* prototype);
-};
 
-extern "C" void* MD5Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsMD5Constructor);
 
 extern "C" void MD5Class__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue MD5Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MD5Prototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue MD5Prototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(MD5Prototype__digestCallback);
 
+
 extern "C" EncodedJSValue MD5Prototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(MD5Prototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMD5Prototype, JSMD5Prototype::Base);
 
-static const HashTableValue JSMD5PrototypeTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MD5Prototype__byteLengthGetterWrap, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD5Prototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD5Prototype__updateCallback, 1 } }
+
+  static const HashTableValue JSMD5PrototypeTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MD5Prototype__byteLengthGetterWrap, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD5Prototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD5Prototype__updateCallback, 1 } }
 };
 
+
+
 const ClassInfo JSMD5Prototype::s_info = { "MD5"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMD5Prototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsMD5Constructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -13700,12 +14726,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsMD5Constructor, (JSGlobalObject * lexicalGlobalObject
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for MD5"_s);
     return JSValue::encode(globalObject->JSMD5Constructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(MD5Prototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMD5* thisObject = jsCast<JSMD5*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -13713,62 +14741,65 @@ JSC_DEFINE_CUSTOM_GETTER(MD5Prototype__byteLengthGetterWrap, (JSGlobalObject * l
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(MD5Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(MD5Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSMD5* thisObject = jsDynamicCast<JSMD5*>(callFrame->thisValue());
+        JSMD5* thisObject = jsDynamicCast<JSMD5*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof MD5"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof MD5"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return MD5Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return MD5Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(MD5Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(MD5Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSMD5* thisObject = jsDynamicCast<JSMD5*>(callFrame->thisValue());
 
-    JSMD5* thisObject = jsDynamicCast<JSMD5*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof MD5"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof MD5"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return MD5Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return MD5Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSMD5Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -13780,11 +14811,12 @@ void JSMD5Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObje
 extern "C" JSC_DECLARE_CUSTOM_GETTER(MD5Class__getByteLengthStatic);
 extern "C" JSC_DECLARE_HOST_FUNCTION(MD5Class__hash);
 
-static const HashTableValue JSMD5ConstructorTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MD5Class__getByteLengthStatic, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD5Class__hash, 2 } }
+  static const HashTableValue JSMD5ConstructorTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MD5Class__getByteLengthStatic, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, MD5Class__hash, 2 } }
 };
 
+
 void JSMD5Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSMD5Prototype* prototype)
 {
     Base::finishCreation(vm, 0, "MD5"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -13793,59 +14825,62 @@ void JSMD5Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject,
     ASSERT(inherits(info()));
 }
 
-JSMD5Constructor::JSMD5Constructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSMD5Constructor::JSMD5Constructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSMD5Constructor* JSMD5Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSMD5Prototype* prototype)
-{
+  }
+
+JSMD5Constructor* JSMD5Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSMD5Prototype* prototype) {
     JSMD5Constructor* ptr = new (NotNull, JSC::allocateCell<JSMD5Constructor>(vm)) JSMD5Constructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSMD5Constructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSMD5Constructor();
     Structure* structure = globalObject->JSMD5Structure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSMD5Structure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSMD5Structure()
+      );
     }
 
     void* ptr = MD5Class__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSMD5* instance = JSMD5::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSMD5Constructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSMD5Prototype* prototype)
 {
+
 }
 
 const ClassInfo JSMD5Constructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMD5Constructor) };
 
-extern "C" EncodedJSValue MD5__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue MD5__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSMD5Constructor());
-}
+  }
 
 JSMD5::~JSMD5()
 {
@@ -13857,7 +14892,7 @@ void JSMD5::destroy(JSCell* cell)
 {
     static_cast<JSMD5*>(cell)->JSMD5::~JSMD5();
 }
-
+  
 const ClassInfo JSMD5::s_info = { "MD5"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMD5) };
 
 void JSMD5::finishCreation(VM& vm)
@@ -13866,38 +14901,37 @@ void JSMD5::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSMD5* JSMD5::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSMD5* ptr = new (NotNull, JSC::allocateCell<JSMD5>(vm)) JSMD5(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* MD5__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSMD5* JSMD5::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSMD5* ptr = new (NotNull, JSC::allocateCell<JSMD5>(vm)) JSMD5(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSMD5* object = JSC::jsDynamicCast<JSMD5*>(cell);
+extern "C" void* MD5__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSMD5* object = JSC::jsDynamicCast<JSMD5*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool MD5__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSMD5* object = JSC::jsDynamicCast<JSMD5*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool MD5__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSMD5* object = JSC::jsDynamicCast<JSMD5*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t MD5__ptrOffset = JSMD5::offsetOfWrapped();
 
 void JSMD5::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -13912,7 +14946,7 @@ void JSMD5::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSMD5::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSMD5Constructor::create(vm, globalObject, WebCore::JSMD5Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSMD5Prototype*>(prototype));
+  return WebCore::JSMD5Constructor::create(vm, globalObject, WebCore::JSMD5Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSMD5Prototype*>(prototype));
 }
 
 JSObject* JSMD5::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -13920,90 +14954,107 @@ JSObject* JSMD5::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSMD5Prototype::create(vm, globalObject, JSMD5Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue MD5__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSMD5Structure();
-    JSMD5* instance = JSMD5::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSMatchedRoutePrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+extern "C" EncodedJSValue MD5__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSMD5Structure();
+  JSMD5* instance = JSMD5::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSMatchedRoutePrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSMatchedRoutePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSMatchedRoutePrototype* ptr = new (NotNull, JSC::allocateCell<JSMatchedRoutePrototype>(vm)) JSMatchedRoutePrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMatchedRoutePrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSMatchedRoutePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSMatchedRoutePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSMatchedRoutePrototype* ptr = new (NotNull, JSC::allocateCell<JSMatchedRoutePrototype>(vm)) JSMatchedRoutePrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* MatchedRouteClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsMatchedRouteConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMatchedRoutePrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSMatchedRoutePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* MatchedRouteClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsMatchedRouteConstructor);
 
 extern "C" void MatchedRouteClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getFilePath(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MatchedRoutePrototype__filePathGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getKind(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MatchedRoutePrototype__kindGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getName(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MatchedRoutePrototype__nameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getParams(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MatchedRoutePrototype__paramsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getPathname(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MatchedRoutePrototype__pathnameGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getQuery(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MatchedRoutePrototype__queryGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getScriptSrc(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MatchedRoutePrototype__scriptSrcGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue MatchedRoutePrototype__getScriptSrc(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(MatchedRoutePrototype__srcGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSMatchedRoutePrototype, JSMatchedRoutePrototype::Base);
 
-static const HashTableValue JSMatchedRoutePrototypeTableValues[] = {
-    { "filePath"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__filePathGetterWrap, 0 } },
-    { "kind"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__kindGetterWrap, 0 } },
-    { "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__nameGetterWrap, 0 } },
-    { "params"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__paramsGetterWrap, 0 } },
-    { "pathname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__pathnameGetterWrap, 0 } },
-    { "query"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__queryGetterWrap, 0 } },
-    { "scriptSrc"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__scriptSrcGetterWrap, 0 } },
-    { "src"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__srcGetterWrap, 0 } }
+
+  static const HashTableValue JSMatchedRoutePrototypeTableValues[] = {
+{ "filePath"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__filePathGetterWrap, 0 } }  ,
+{ "kind"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__kindGetterWrap, 0 } }  ,
+{ "name"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__nameGetterWrap, 0 } }  ,
+{ "params"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__paramsGetterWrap, 0 } }  ,
+{ "pathname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__pathnameGetterWrap, 0 } }  ,
+{ "query"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__queryGetterWrap, 0 } }  ,
+{ "scriptSrc"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__scriptSrcGetterWrap, 0 } }  ,
+{ "src"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, MatchedRoutePrototype__srcGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSMatchedRoutePrototype::s_info = { "MatchedRoute"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMatchedRoutePrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsMatchedRouteConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -14014,255 +15065,289 @@ JSC_DEFINE_CUSTOM_GETTER(jsMatchedRouteConstructor, (JSGlobalObject * lexicalGlo
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for MatchedRoute"_s);
     return JSValue::encode(globalObject->JSMatchedRouteConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(MatchedRoutePrototype__filePathGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_filePath.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        MatchedRoutePrototype__getFilePath(thisObject->wrapped(), globalObject));
+        MatchedRoutePrototype__getFilePath(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_filePath.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void MatchedRoutePrototype__filePathSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    thisObject->m_filePath.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue MatchedRoutePrototype__filePathGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void MatchedRoutePrototype__filePathSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
+      thisObject->m_filePath.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue MatchedRoutePrototype__filePathGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_filePath.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(MatchedRoutePrototype__kindGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_kind.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        MatchedRoutePrototype__getKind(thisObject->wrapped(), globalObject));
+        MatchedRoutePrototype__getKind(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_kind.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void MatchedRoutePrototype__kindSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    thisObject->m_kind.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue MatchedRoutePrototype__kindGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void MatchedRoutePrototype__kindSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
+      thisObject->m_kind.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue MatchedRoutePrototype__kindGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_kind.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(MatchedRoutePrototype__nameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_name.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        MatchedRoutePrototype__getName(thisObject->wrapped(), globalObject));
+        MatchedRoutePrototype__getName(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_name.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void MatchedRoutePrototype__nameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    thisObject->m_name.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue MatchedRoutePrototype__nameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void MatchedRoutePrototype__nameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
+      thisObject->m_name.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue MatchedRoutePrototype__nameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_name.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(MatchedRoutePrototype__paramsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_params.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        MatchedRoutePrototype__getParams(thisObject->wrapped(), globalObject));
+        MatchedRoutePrototype__getParams(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_params.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void MatchedRoutePrototype__paramsSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    thisObject->m_params.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue MatchedRoutePrototype__paramsGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void MatchedRoutePrototype__paramsSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
+      thisObject->m_params.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue MatchedRoutePrototype__paramsGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_params.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(MatchedRoutePrototype__pathnameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_pathname.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        MatchedRoutePrototype__getPathname(thisObject->wrapped(), globalObject));
+        MatchedRoutePrototype__getPathname(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_pathname.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void MatchedRoutePrototype__pathnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    thisObject->m_pathname.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue MatchedRoutePrototype__pathnameGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void MatchedRoutePrototype__pathnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
+      thisObject->m_pathname.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue MatchedRoutePrototype__pathnameGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_pathname.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(MatchedRoutePrototype__queryGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_query.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        MatchedRoutePrototype__getQuery(thisObject->wrapped(), globalObject));
+        MatchedRoutePrototype__getQuery(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_query.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void MatchedRoutePrototype__querySetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    thisObject->m_query.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue MatchedRoutePrototype__queryGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void MatchedRoutePrototype__querySetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
+      thisObject->m_query.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue MatchedRoutePrototype__queryGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_query.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(MatchedRoutePrototype__scriptSrcGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_scriptSrc.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        MatchedRoutePrototype__getScriptSrc(thisObject->wrapped(), globalObject));
+        MatchedRoutePrototype__getScriptSrc(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_scriptSrc.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void MatchedRoutePrototype__scriptSrcSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    thisObject->m_scriptSrc.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue MatchedRoutePrototype__scriptSrcGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void MatchedRoutePrototype__scriptSrcSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
+      thisObject->m_scriptSrc.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue MatchedRoutePrototype__scriptSrcGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_scriptSrc.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(MatchedRoutePrototype__srcGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_scriptSrc.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        MatchedRoutePrototype__getScriptSrc(thisObject->wrapped(), globalObject));
+        MatchedRoutePrototype__getScriptSrc(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_scriptSrc.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void MatchedRoutePrototype__srcSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
-    thisObject->m_scriptSrc.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue MatchedRoutePrototype__srcGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void MatchedRoutePrototype__srcSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
+      thisObject->m_scriptSrc.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue MatchedRoutePrototype__srcGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSMatchedRoute*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_scriptSrc.get());
-}
+  }
+  
+  
 
 void JSMatchedRoutePrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -14281,7 +15366,7 @@ void JSMatchedRoute::destroy(JSCell* cell)
 {
     static_cast<JSMatchedRoute*>(cell)->JSMatchedRoute::~JSMatchedRoute();
 }
-
+  
 const ClassInfo JSMatchedRoute::s_info = { "MatchedRoute"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSMatchedRoute) };
 
 void JSMatchedRoute::finishCreation(VM& vm)
@@ -14290,38 +15375,37 @@ void JSMatchedRoute::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSMatchedRoute* JSMatchedRoute::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSMatchedRoute* ptr = new (NotNull, JSC::allocateCell<JSMatchedRoute>(vm)) JSMatchedRoute(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* MatchedRoute__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSMatchedRoute* JSMatchedRoute::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSMatchedRoute* ptr = new (NotNull, JSC::allocateCell<JSMatchedRoute>(vm)) JSMatchedRoute(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSMatchedRoute* object = JSC::jsDynamicCast<JSMatchedRoute*>(cell);
+extern "C" void* MatchedRoute__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSMatchedRoute* object = JSC::jsDynamicCast<JSMatchedRoute*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool MatchedRoute__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSMatchedRoute* object = JSC::jsDynamicCast<JSMatchedRoute*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool MatchedRoute__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSMatchedRoute* object = JSC::jsDynamicCast<JSMatchedRoute*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t MatchedRoute__ptrOffset = JSMatchedRoute::offsetOfWrapped();
 
 void JSMatchedRoute::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -14334,18 +15418,19 @@ void JSMatchedRoute::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSMatchedRoute::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSMatchedRoutePrototype::create(vm, globalObject, JSMatchedRoutePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue MatchedRoute__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSMatchedRouteStructure();
-    JSMatchedRoute* instance = JSMatchedRoute::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue MatchedRoute__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSMatchedRouteStructure();
+  JSMatchedRoute* instance = JSMatchedRoute::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -14354,7 +15439,7 @@ void JSMatchedRoute::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -14363,22 +15448,23 @@ DEFINE_VISIT_CHILDREN(JSMatchedRoute);
 template<typename Visitor>
 void JSMatchedRoute::visitAdditionalChildren(Visitor& visitor)
 {
-    JSMatchedRoute* thisObject = this;
+  JSMatchedRoute* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_filePath);
+    
+        visitor.append(thisObject->m_filePath);
     visitor.append(thisObject->m_kind);
     visitor.append(thisObject->m_name);
     visitor.append(thisObject->m_params);
     visitor.append(thisObject->m_pathname);
     visitor.append(thisObject->m_query);
     visitor.append(thisObject->m_scriptSrc);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSMatchedRoute);
 
 template<typename Visitor>
-void JSMatchedRoute::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSMatchedRoute::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSMatchedRoute* thisObject = jsCast<JSMatchedRoute*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -14386,435 +15472,533 @@ void JSMatchedRoute::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSMatchedRoute);
-class JSNodeJSFSPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSNodeJSFSPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSNodeJSFSPrototype* ptr = new (NotNull, JSC::allocateCell<JSNodeJSFSPrototype>(vm)) JSNodeJSFSPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSNodeJSFSPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSNodeJSFSPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSNodeJSFSPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSNodeJSFSPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSNodeJSFSPrototype* ptr = new (NotNull, JSC::allocateCell<JSNodeJSFSPrototype>(vm)) JSNodeJSFSPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSNodeJSFSPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSNodeJSFSPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSNodeJSFSConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSNodeJSFSConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSNodeJSFSPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSNodeJSFSConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSNodeJSFSPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSNodeJSFSConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForNodeJSFSConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForNodeJSFSConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForNodeJSFSConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForNodeJSFSConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSNodeJSFSPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSNodeJSFSConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSNodeJSFSPrototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSNodeJSFSConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForNodeJSFSConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForNodeJSFSConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForNodeJSFSConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForNodeJSFSConstructor = std::forward<decltype(space)>(space); });
-    }
+extern "C" void* NodeJSFSClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsNodeJSFSConstructor);
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSNodeJSFSPrototype* prototype);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSNodeJSFSConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSNodeJSFSPrototype* prototype);
-};
-
-extern "C" void* NodeJSFSClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsNodeJSFSConstructor);
 
 extern "C" void NodeJSFSClass__finalize(void*);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__access(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__accessCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__accessSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__accessSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__appendFile(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__appendFileCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__appendFileSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__appendFileSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__chmod(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__chmodCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__chmodSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__chmodSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__chown(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__chownCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__chownSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__chownSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__close(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__closeCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__closeSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__closeSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__copyFile(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__copyFileCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__copyFileSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__copyFileSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__cp(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__cpCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__cpSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__cpSyncCallback);
 
+
 extern "C" JSC::EncodedJSValue NodeJSFSPrototype__getDirent(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(NodeJSFSPrototype__DirentGetterWrap);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__exists(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__existsCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__existsSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__existsSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fchmod(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fchmodCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fchmodSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fchmodSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fchown(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fchownCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fchownSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fchownSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fdatasync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fdatasyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fdatasyncSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fdatasyncSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fstat(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fstatCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fstatSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fstatSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fsync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fsyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__fsyncSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__fsyncSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__ftruncate(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__ftruncateCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__ftruncateSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__ftruncateSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__futimes(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__futimesCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__futimesSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__futimesSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__lchmod(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__lchmodCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__lchmodSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__lchmodSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__lchown(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__lchownCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__lchownSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__lchownSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__link(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__linkCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__linkSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__linkSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__lstat(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__lstatCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__lstatSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__lstatSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__lutimes(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__lutimesCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__lutimesSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__lutimesSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__mkdir(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__mkdirCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__mkdirSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__mkdirSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__mkdtemp(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__mkdtempCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__mkdtempSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__mkdtempSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__open(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__openCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__opendir(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__opendirCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__opendirSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__opendirSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__openSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__openSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__read(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readdir(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readdirCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readdirSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readdirSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readFile(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readFileCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readFileSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readFileSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readlink(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readlinkCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readlinkSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readlinkSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readv(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readvCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__readvSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__readvSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__realpath(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__realpathCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__realpathSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__realpathSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__rename(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__renameCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__renameSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__renameSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__rm(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__rmCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__rmdir(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__rmdirCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__rmdirSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__rmdirSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__rmSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__rmSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__stat(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__statCallback);
 
+
 extern "C" JSC::EncodedJSValue NodeJSFSPrototype__getStats(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(NodeJSFSPrototype__StatsGetterWrap);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__statSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__statSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__symlink(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__symlinkCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__symlinkSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__symlinkSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__truncate(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__truncateCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__truncateSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__truncateSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__unlink(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__unlinkCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__unlinkSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__unlinkSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__unwatchFile(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__unwatchFileCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__utimes(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__utimesCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__utimesSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__utimesSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__watch(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__watchCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__watchFile(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__watchFileCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__write(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__writeCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__writeFile(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__writeFileCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__writeFileSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__writeFileSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__writeSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__writeSyncCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__writev(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__writevCallback);
 
+
 extern "C" EncodedJSValue NodeJSFSPrototype__writevSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(NodeJSFSPrototype__writevSyncCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSNodeJSFSPrototype, JSNodeJSFSPrototype::Base);
 
-static const HashTableValue JSNodeJSFSPrototypeTableValues[] = {
-    { "access"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__accessCallback, 3 } },
-    { "accessSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__accessSyncCallback, 2 } },
-    { "appendFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__appendFileCallback, 4 } },
-    { "appendFileSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__appendFileSyncCallback, 3 } },
-    { "chmod"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__chmodCallback, 3 } },
-    { "chmodSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__chmodSyncCallback, 2 } },
-    { "chown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__chownCallback, 4 } },
-    { "chownSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__chownSyncCallback, 3 } },
-    { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__closeCallback, 1 } },
-    { "closeSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__closeSyncCallback, 1 } },
-    { "copyFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__copyFileCallback, 4 } },
-    { "copyFileSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__copyFileSyncCallback, 3 } },
-    { "cp"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__cpCallback, 2 } },
-    { "cpSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__cpSyncCallback, 2 } },
-    { "Dirent"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, NodeJSFSPrototype__DirentGetterWrap, 0 } },
-    { "exists"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__existsCallback, 2 } },
-    { "existsSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__existsSyncCallback, 1 } },
-    { "fchmod"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fchmodCallback, 3 } },
-    { "fchmodSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fchmodSyncCallback, 2 } },
-    { "fchown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fchownCallback, 4 } },
-    { "fchownSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fchownSyncCallback, 3 } },
-    { "fdatasync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fdatasyncCallback, 2 } },
-    { "fdatasyncSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fdatasyncSyncCallback, 1 } },
-    { "fstat"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fstatCallback, 1 } },
-    { "fstatSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fstatSyncCallback, 1 } },
-    { "fsync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fsyncCallback, 2 } },
-    { "fsyncSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fsyncSyncCallback, 1 } },
-    { "ftruncate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__ftruncateCallback, 1 } },
-    { "ftruncateSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__ftruncateSyncCallback, 1 } },
-    { "futimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__futimesCallback, 4 } },
-    { "futimesSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__futimesSyncCallback, 3 } },
-    { "lchmod"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lchmodCallback, 3 } },
-    { "lchmodSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lchmodSyncCallback, 2 } },
-    { "lchown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lchownCallback, 4 } },
-    { "lchownSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lchownSyncCallback, 3 } },
-    { "link"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__linkCallback, 3 } },
-    { "linkSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__linkSyncCallback, 2 } },
-    { "lstat"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lstatCallback, 1 } },
-    { "lstatSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lstatSyncCallback, 1 } },
-    { "lutimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lutimesCallback, 4 } },
-    { "lutimesSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lutimesSyncCallback, 3 } },
-    { "mkdir"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__mkdirCallback, 3 } },
-    { "mkdirSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__mkdirSyncCallback, 2 } },
-    { "mkdtemp"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__mkdtempCallback, 3 } },
-    { "mkdtempSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__mkdtempSyncCallback, 2 } },
-    { "open"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__openCallback, 4 } },
-    { "opendir"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__opendirCallback, 3 } },
-    { "opendirSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__opendirSyncCallback, 2 } },
-    { "openSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__openSyncCallback, 3 } },
-    { "read"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readCallback, 6 } },
-    { "readdir"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readdirCallback, 3 } },
-    { "readdirSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readdirSyncCallback, 2 } },
-    { "readFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readFileCallback, 3 } },
-    { "readFileSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readFileSyncCallback, 2 } },
-    { "readlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readlinkCallback, 3 } },
-    { "readlinkSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readlinkSyncCallback, 2 } },
-    { "readSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readSyncCallback, 5 } },
-    { "readv"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readvCallback, 4 } },
-    { "readvSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readvSyncCallback, 3 } },
-    { "realpath"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__realpathCallback, 3 } },
-    { "realpathSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__realpathSyncCallback, 2 } },
-    { "rename"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__renameCallback, 3 } },
-    { "renameSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__renameSyncCallback, 2 } },
-    { "rm"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__rmCallback, 3 } },
-    { "rmdir"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__rmdirCallback, 3 } },
-    { "rmdirSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__rmdirSyncCallback, 2 } },
-    { "rmSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__rmSyncCallback, 2 } },
-    { "stat"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__statCallback, 1 } },
-    { "Stats"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, NodeJSFSPrototype__StatsGetterWrap, 0 } },
-    { "statSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__statSyncCallback, 1 } },
-    { "symlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__symlinkCallback, 4 } },
-    { "symlinkSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__symlinkSyncCallback, 3 } },
-    { "truncate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__truncateCallback, 3 } },
-    { "truncateSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__truncateSyncCallback, 2 } },
-    { "unlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__unlinkCallback, 2 } },
-    { "unlinkSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__unlinkSyncCallback, 1 } },
-    { "unwatchFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__unwatchFileCallback, 2 } },
-    { "utimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__utimesCallback, 4 } },
-    { "utimesSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__utimesSyncCallback, 3 } },
-    { "watch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__watchCallback, 3 } },
-    { "watchFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__watchFileCallback, 3 } },
-    { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writeCallback, 6 } },
-    { "writeFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writeFileCallback, 4 } },
-    { "writeFileSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writeFileSyncCallback, 3 } },
-    { "writeSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writeSyncCallback, 5 } },
-    { "writev"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writevCallback, 4 } },
-    { "writevSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writevSyncCallback, 3 } }
+
+  static const HashTableValue JSNodeJSFSPrototypeTableValues[] = {
+{ "access"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__accessCallback, 3 } }  ,
+{ "accessSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__accessSyncCallback, 2 } }  ,
+{ "appendFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__appendFileCallback, 4 } }  ,
+{ "appendFileSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__appendFileSyncCallback, 3 } }  ,
+{ "chmod"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__chmodCallback, 3 } }  ,
+{ "chmodSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__chmodSyncCallback, 2 } }  ,
+{ "chown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__chownCallback, 4 } }  ,
+{ "chownSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__chownSyncCallback, 3 } }  ,
+{ "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__closeCallback, 1 } }  ,
+{ "closeSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__closeSyncCallback, 1 } }  ,
+{ "copyFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__copyFileCallback, 4 } }  ,
+{ "copyFileSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__copyFileSyncCallback, 3 } }  ,
+{ "cp"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__cpCallback, 2 } }  ,
+{ "cpSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__cpSyncCallback, 2 } }  ,
+{ "Dirent"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, NodeJSFSPrototype__DirentGetterWrap, 0 } }  ,
+{ "exists"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__existsCallback, 2 } }  ,
+{ "existsSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__existsSyncCallback, 1 } }  ,
+{ "fchmod"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fchmodCallback, 3 } }  ,
+{ "fchmodSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fchmodSyncCallback, 2 } }  ,
+{ "fchown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fchownCallback, 4 } }  ,
+{ "fchownSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fchownSyncCallback, 3 } }  ,
+{ "fdatasync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fdatasyncCallback, 2 } }  ,
+{ "fdatasyncSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fdatasyncSyncCallback, 1 } }  ,
+{ "fstat"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fstatCallback, 1 } }  ,
+{ "fstatSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fstatSyncCallback, 1 } }  ,
+{ "fsync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fsyncCallback, 2 } }  ,
+{ "fsyncSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__fsyncSyncCallback, 1 } }  ,
+{ "ftruncate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__ftruncateCallback, 1 } }  ,
+{ "ftruncateSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__ftruncateSyncCallback, 1 } }  ,
+{ "futimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__futimesCallback, 4 } }  ,
+{ "futimesSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__futimesSyncCallback, 3 } }  ,
+{ "lchmod"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lchmodCallback, 3 } }  ,
+{ "lchmodSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lchmodSyncCallback, 2 } }  ,
+{ "lchown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lchownCallback, 4 } }  ,
+{ "lchownSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lchownSyncCallback, 3 } }  ,
+{ "link"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__linkCallback, 3 } }  ,
+{ "linkSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__linkSyncCallback, 2 } }  ,
+{ "lstat"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lstatCallback, 1 } }  ,
+{ "lstatSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lstatSyncCallback, 1 } }  ,
+{ "lutimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lutimesCallback, 4 } }  ,
+{ "lutimesSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__lutimesSyncCallback, 3 } }  ,
+{ "mkdir"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__mkdirCallback, 3 } }  ,
+{ "mkdirSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__mkdirSyncCallback, 2 } }  ,
+{ "mkdtemp"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__mkdtempCallback, 3 } }  ,
+{ "mkdtempSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__mkdtempSyncCallback, 2 } }  ,
+{ "open"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__openCallback, 4 } }  ,
+{ "opendir"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__opendirCallback, 3 } }  ,
+{ "opendirSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__opendirSyncCallback, 2 } }  ,
+{ "openSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__openSyncCallback, 3 } }  ,
+{ "read"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readCallback, 6 } }  ,
+{ "readdir"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readdirCallback, 3 } }  ,
+{ "readdirSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readdirSyncCallback, 2 } }  ,
+{ "readFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readFileCallback, 3 } }  ,
+{ "readFileSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readFileSyncCallback, 2 } }  ,
+{ "readlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readlinkCallback, 3 } }  ,
+{ "readlinkSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readlinkSyncCallback, 2 } }  ,
+{ "readSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readSyncCallback, 5 } }  ,
+{ "readv"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readvCallback, 4 } }  ,
+{ "readvSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__readvSyncCallback, 3 } }  ,
+{ "realpath"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__realpathCallback, 3 } }  ,
+{ "realpathSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__realpathSyncCallback, 2 } }  ,
+{ "rename"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__renameCallback, 3 } }  ,
+{ "renameSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__renameSyncCallback, 2 } }  ,
+{ "rm"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__rmCallback, 3 } }  ,
+{ "rmdir"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__rmdirCallback, 3 } }  ,
+{ "rmdirSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__rmdirSyncCallback, 2 } }  ,
+{ "rmSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__rmSyncCallback, 2 } }  ,
+{ "stat"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__statCallback, 1 } }  ,
+{ "Stats"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, NodeJSFSPrototype__StatsGetterWrap, 0 } }  ,
+{ "statSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__statSyncCallback, 1 } }  ,
+{ "symlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__symlinkCallback, 4 } }  ,
+{ "symlinkSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__symlinkSyncCallback, 3 } }  ,
+{ "truncate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__truncateCallback, 3 } }  ,
+{ "truncateSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__truncateSyncCallback, 2 } }  ,
+{ "unlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__unlinkCallback, 2 } }  ,
+{ "unlinkSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__unlinkSyncCallback, 1 } }  ,
+{ "unwatchFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__unwatchFileCallback, 2 } }  ,
+{ "utimes"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__utimesCallback, 4 } }  ,
+{ "utimesSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__utimesSyncCallback, 3 } }  ,
+{ "watch"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__watchCallback, 3 } }  ,
+{ "watchFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__watchFileCallback, 3 } }  ,
+{ "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writeCallback, 6 } }  ,
+{ "writeFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writeFileCallback, 4 } }  ,
+{ "writeFileSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writeFileSyncCallback, 3 } }  ,
+{ "writeSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writeSyncCallback, 5 } }  ,
+{ "writev"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writevCallback, 4 } }  ,
+{ "writevSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, NodeJSFSPrototype__writevSyncCallback, 3 } }
 };
 
+
+
 const ClassInfo JSNodeJSFSPrototype::s_info = { "NodeJSFS"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSNodeJSFSPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsNodeJSFSConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -14825,404 +16009,420 @@ JSC_DEFINE_CUSTOM_GETTER(jsNodeJSFSConstructor, (JSGlobalObject * lexicalGlobalO
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for NodeJSFS"_s);
     return JSValue::encode(globalObject->JSNodeJSFSConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__accessCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__accessCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return NodeJSFSPrototype__access(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__access(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__accessSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__accessSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__accessSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__accessSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__appendFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__appendFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__appendFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__appendFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__appendFileSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__appendFileSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__appendFileSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__appendFileSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__chmodCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__chmodCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__chmod(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__chmod(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__chmodSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__chmodSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__chmodSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__chmodSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__chownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__chownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__chown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__chown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__chownSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__chownSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__chownSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__chownSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__close(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__close(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__closeSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__closeSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__closeSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__closeSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__copyFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__copyFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__copyFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__copyFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__copyFileSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__copyFileSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__copyFileSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__copyFileSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__cpCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__cpCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__cp(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__cp(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__cpSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__cpSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__cpSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return NodeJSFSPrototype__cpSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(NodeJSFSPrototype__DirentGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSNodeJSFS* thisObject = jsCast<JSNodeJSFS*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -15230,1495 +16430,1549 @@ JSC_DEFINE_CUSTOM_GETTER(NodeJSFSPrototype__DirentGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__existsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__existsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__exists(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__exists(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__existsSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__existsSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__existsSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__existsSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fchmodCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fchmodCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fchmod(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fchmod(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fchmodSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fchmodSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fchmodSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fchmodSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fchownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fchownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fchown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fchown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fchownSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fchownSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fchownSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fchownSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fdatasyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fdatasyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fdatasync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fdatasync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fdatasyncSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fdatasyncSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fdatasyncSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fdatasyncSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fstatCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fstatCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fstat(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fstat(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fstatSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fstatSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fstatSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fstatSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fsyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fsyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fsync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fsync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fsyncSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__fsyncSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__fsyncSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__fsyncSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__ftruncateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__ftruncateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__ftruncate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__ftruncate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__ftruncateSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__ftruncateSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__ftruncateSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__ftruncateSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__futimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__futimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__futimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__futimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__futimesSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__futimesSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__futimesSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__futimesSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lchmodCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lchmodCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__lchmod(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__lchmod(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lchmodSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lchmodSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__lchmodSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__lchmodSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lchownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lchownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__lchown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__lchown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lchownSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lchownSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__lchownSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__lchownSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__linkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__linkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__link(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__link(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__linkSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__linkSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__linkSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__linkSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lstatCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lstatCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__lstat(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__lstat(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lstatSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lstatSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__lstatSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__lstatSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lutimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lutimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__lutimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__lutimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lutimesSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__lutimesSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__lutimesSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__lutimesSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__mkdirCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__mkdirCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__mkdir(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__mkdir(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__mkdirSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__mkdirSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__mkdirSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__mkdirSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__mkdtempCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__mkdtempCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__mkdtemp(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__mkdtemp(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__mkdtempSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__mkdtempSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__mkdtempSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__mkdtempSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__openCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__openCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__open(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__open(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__opendirCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__opendirCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__opendir(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__opendir(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__opendirSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__opendirSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__opendirSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__opendirSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__openSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__openSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__openSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__openSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__read(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__read(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readdirCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readdirCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readdir(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readdir(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readdirSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readdirSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readdirSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readdirSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readFileSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readFileSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readFileSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readFileSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readlinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readlinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readlink(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readlink(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readlinkSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readlinkSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readlinkSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readlinkSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readvCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readvCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readv(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readv(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readvSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__readvSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__readvSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__readvSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__realpathCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__realpathCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__realpath(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__realpath(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__realpathSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__realpathSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__realpathSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__realpathSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__renameCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__renameCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__rename(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__rename(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__renameSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__renameSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__renameSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__renameSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__rmCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__rmCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__rm(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__rm(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__rmdirCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__rmdirCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__rmdir(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__rmdir(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__rmdirSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__rmdirSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__rmdirSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__rmdirSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__rmSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__rmSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__rmSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__rmSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__statCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__statCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__stat(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return NodeJSFSPrototype__stat(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(NodeJSFSPrototype__StatsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSNodeJSFS* thisObject = jsCast<JSNodeJSFS*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -16726,510 +17980,529 @@ JSC_DEFINE_CUSTOM_GETTER(NodeJSFSPrototype__StatsGetterWrap, (JSGlobalObject * l
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__statSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__statSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__statSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__statSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__symlinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__symlinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__symlink(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__symlink(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__symlinkSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__symlinkSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__symlinkSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__symlinkSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__truncateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__truncateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__truncate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__truncate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__truncateSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__truncateSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__truncateSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__truncateSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__unlinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__unlinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__unlink(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__unlink(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__unlinkSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__unlinkSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__unlinkSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__unlinkSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__unwatchFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__unwatchFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__unwatchFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__unwatchFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__utimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__utimesCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__utimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__utimes(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__utimesSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__utimesSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__utimesSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__utimesSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__watchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__watchCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__watch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__watch(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__watchFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__watchFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__watchFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__watchFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__write(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__write(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writeFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writeFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__writeFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__writeFile(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writeFileSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writeFileSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__writeFileSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__writeFileSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writeSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writeSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__writeSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__writeSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writevCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writevCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__writev(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return NodeJSFSPrototype__writev(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writevSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(NodeJSFSPrototype__writevSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
 
-    JSNodeJSFS* thisObject = jsDynamicCast<JSNodeJSFS*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof NodeJSFS"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return NodeJSFSPrototype__writevSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return NodeJSFSPrototype__writevSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSNodeJSFSPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -17241,64 +18514,67 @@ void JSNodeJSFSPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globa
 void JSNodeJSFSConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSNodeJSFSPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "NodeJSFS"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSNodeJSFSConstructor::JSNodeJSFSConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSNodeJSFSConstructor::JSNodeJSFSConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSNodeJSFSConstructor* JSNodeJSFSConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSNodeJSFSPrototype* prototype)
-{
+  }
+
+JSNodeJSFSConstructor* JSNodeJSFSConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSNodeJSFSPrototype* prototype) {
     JSNodeJSFSConstructor* ptr = new (NotNull, JSC::allocateCell<JSNodeJSFSConstructor>(vm)) JSNodeJSFSConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSNodeJSFSConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSNodeJSFSConstructor();
     Structure* structure = globalObject->JSNodeJSFSStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSNodeJSFSStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSNodeJSFSStructure()
+      );
     }
 
     void* ptr = NodeJSFSClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSNodeJSFS* instance = JSNodeJSFS::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSNodeJSFSConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSNodeJSFSPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSNodeJSFSConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSNodeJSFSConstructor) };
 
-extern "C" EncodedJSValue NodeJSFS__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue NodeJSFS__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSNodeJSFSConstructor());
-}
+  }
 
 JSNodeJSFS::~JSNodeJSFS()
 {
@@ -17307,7 +18583,7 @@ void JSNodeJSFS::destroy(JSCell* cell)
 {
     static_cast<JSNodeJSFS*>(cell)->JSNodeJSFS::~JSNodeJSFS();
 }
-
+  
 const ClassInfo JSNodeJSFS::s_info = { "NodeJSFS"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSNodeJSFS) };
 
 void JSNodeJSFS::finishCreation(VM& vm)
@@ -17316,38 +18592,37 @@ void JSNodeJSFS::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSNodeJSFS* JSNodeJSFS::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSNodeJSFS* ptr = new (NotNull, JSC::allocateCell<JSNodeJSFS>(vm)) JSNodeJSFS(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* NodeJSFS__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSNodeJSFS* JSNodeJSFS::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSNodeJSFS* ptr = new (NotNull, JSC::allocateCell<JSNodeJSFS>(vm)) JSNodeJSFS(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSNodeJSFS* object = JSC::jsDynamicCast<JSNodeJSFS*>(cell);
+extern "C" void* NodeJSFS__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSNodeJSFS* object = JSC::jsDynamicCast<JSNodeJSFS*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool NodeJSFS__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSNodeJSFS* object = JSC::jsDynamicCast<JSNodeJSFS*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool NodeJSFS__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSNodeJSFS* object = JSC::jsDynamicCast<JSNodeJSFS*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t NodeJSFS__ptrOffset = JSNodeJSFS::offsetOfWrapped();
 
 void JSNodeJSFS::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -17362,7 +18637,7 @@ void JSNodeJSFS::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSNodeJSFS::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSNodeJSFSConstructor::create(vm, globalObject, WebCore::JSNodeJSFSConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSNodeJSFSPrototype*>(prototype));
+  return WebCore::JSNodeJSFSConstructor::create(vm, globalObject, WebCore::JSNodeJSFSConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSNodeJSFSPrototype*>(prototype));
 }
 
 JSObject* JSNodeJSFS::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -17370,175 +18645,205 @@ JSObject* JSNodeJSFS::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSNodeJSFSPrototype::create(vm, globalObject, JSNodeJSFSPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue NodeJSFS__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSNodeJSFSStructure();
-    JSNodeJSFS* instance = JSNodeJSFS::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSRequestPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSRequestPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSRequestPrototype* ptr = new (NotNull, JSC::allocateCell<JSRequestPrototype>(vm)) JSRequestPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSRequestPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSRequestPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue NodeJSFS__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSNodeJSFSStructure();
+  JSNodeJSFS* instance = JSNodeJSFS::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSRequestPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSRequestPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSRequestPrototype* ptr = new (NotNull, JSC::allocateCell<JSRequestPrototype>(vm)) JSRequestPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSRequestPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSRequestPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSRequestConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSRequestConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSRequestPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSRequestConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSRequestPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSRequestConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForRequestConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForRequestConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForRequestConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForRequestConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSRequestPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSRequestConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSRequestPrototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSRequestConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForRequestConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForRequestConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForRequestConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForRequestConstructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSRequestPrototype* prototype);
+extern "C" void* RequestClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsRequestConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSRequestConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSRequestPrototype* prototype);
-};
 
-extern "C" void* RequestClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsRequestConstructor);
 
 extern "C" void RequestClass__finalize(void*);
 
+
 extern "C" EncodedJSValue RequestPrototype__getArrayBuffer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(RequestPrototype__arrayBufferCallback);
 
+
 extern "C" EncodedJSValue RequestPrototype__getBlob(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(RequestPrototype__blobCallback);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getBody(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__bodyGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getBodyUsed(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__bodyUsedGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getCache(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__cacheGetterWrap);
 
+
 extern "C" EncodedJSValue RequestPrototype__doClone(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(RequestPrototype__cloneCallback);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getCredentials(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__credentialsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getDestination(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__destinationGetterWrap);
 
+
 extern "C" EncodedJSValue RequestPrototype__getFormData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(RequestPrototype__formDataCallback);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getHeaders(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__headersGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getIntegrity(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__integrityGetterWrap);
 
+
 extern "C" EncodedJSValue RequestPrototype__getJSON(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(RequestPrototype__jsonCallback);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getMethod(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__methodGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getMode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__modeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getRedirect(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__redirectGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getReferrer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__referrerGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getReferrerPolicy(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__referrerPolicyGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getSignal(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__signalGetterWrap);
 
+
 extern "C" EncodedJSValue RequestPrototype__getText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(RequestPrototype__textCallback);
 
+
 extern "C" JSC::EncodedJSValue RequestPrototype__getUrl(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__urlGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSRequestPrototype, JSRequestPrototype::Base);
 
-static const HashTableValue JSRequestPrototypeTableValues[] = {
-    { "arrayBuffer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__arrayBufferCallback, 0 } },
-    { "blob"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__blobCallback, 0 } },
-    { "body"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__bodyGetterWrap, 0 } },
-    { "bodyUsed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__bodyUsedGetterWrap, 0 } },
-    { "cache"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__cacheGetterWrap, 0 } },
-    { "clone"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__cloneCallback, 1 } },
-    { "credentials"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__credentialsGetterWrap, 0 } },
-    { "destination"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__destinationGetterWrap, 0 } },
-    { "formData"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__formDataCallback, 0 } },
-    { "headers"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__headersGetterWrap, 0 } },
-    { "integrity"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__integrityGetterWrap, 0 } },
-    { "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__jsonCallback, 0 } },
-    { "method"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__methodGetterWrap, 0 } },
-    { "mode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__modeGetterWrap, 0 } },
-    { "redirect"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__redirectGetterWrap, 0 } },
-    { "referrer"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__referrerGetterWrap, 0 } },
-    { "referrerPolicy"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__referrerPolicyGetterWrap, 0 } },
-    { "signal"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__signalGetterWrap, 0 } },
-    { "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__textCallback, 0 } },
-    { "url"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__urlGetterWrap, 0 } }
+
+  static const HashTableValue JSRequestPrototypeTableValues[] = {
+{ "arrayBuffer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__arrayBufferCallback, 0 } }  ,
+{ "blob"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__blobCallback, 0 } }  ,
+{ "body"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__bodyGetterWrap, 0 } }  ,
+{ "bodyUsed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__bodyUsedGetterWrap, 0 } }  ,
+{ "cache"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__cacheGetterWrap, 0 } }  ,
+{ "clone"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__cloneCallback, 1 } }  ,
+{ "credentials"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__credentialsGetterWrap, 0 } }  ,
+{ "destination"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__destinationGetterWrap, 0 } }  ,
+{ "formData"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__formDataCallback, 0 } }  ,
+{ "headers"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__headersGetterWrap, 0 } }  ,
+{ "integrity"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__integrityGetterWrap, 0 } }  ,
+{ "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__jsonCallback, 0 } }  ,
+{ "method"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__methodGetterWrap, 0 } }  ,
+{ "mode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__modeGetterWrap, 0 } }  ,
+{ "redirect"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__redirectGetterWrap, 0 } }  ,
+{ "referrer"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__referrerGetterWrap, 0 } }  ,
+{ "referrerPolicy"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__referrerPolicyGetterWrap, 0 } }  ,
+{ "signal"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__signalGetterWrap, 0 } }  ,
+{ "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__textCallback, 0 } }  ,
+{ "url"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__urlGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSRequestPrototype::s_info = { "Request"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSRequestPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsRequestConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -17549,99 +18854,107 @@ JSC_DEFINE_CUSTOM_GETTER(jsRequestConstructor, (JSGlobalObject * lexicalGlobalOb
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Request"_s);
     return JSValue::encode(globalObject->JSRequestConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(RequestPrototype__arrayBufferCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(RequestPrototype__arrayBufferCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
-        return JSValue::encode({});
-    }
+        JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return RequestPrototype__getArrayBuffer(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return RequestPrototype__getArrayBuffer(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(RequestPrototype__blobCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(RequestPrototype__blobCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
 
-    JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return RequestPrototype__getBlob(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return RequestPrototype__getBlob(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__bodyGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_body.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        RequestPrototype__getBody(thisObject->wrapped(), globalObject));
+        RequestPrototype__getBody(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_body.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void RequestPrototype__bodySetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
-    thisObject->m_body.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue RequestPrototype__bodyGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void RequestPrototype__bodySetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
+      thisObject->m_body.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue RequestPrototype__bodyGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_body.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__bodyUsedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17649,11 +18962,12 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__bodyUsedGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__cacheGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17661,39 +18975,41 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__cacheGetterWrap, (JSGlobalObject * le
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(RequestPrototype__cloneCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(RequestPrototype__cloneCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
+        JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return RequestPrototype__doClone(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return RequestPrototype__doClone(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__credentialsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17701,11 +19017,12 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__credentialsGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__destinationGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17713,70 +19030,76 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__destinationGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(RequestPrototype__formDataCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(RequestPrototype__formDataCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
+        JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return RequestPrototype__getFormData(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return RequestPrototype__getFormData(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__headersGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_headers.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        RequestPrototype__getHeaders(thisObject->wrapped(), globalObject));
+        RequestPrototype__getHeaders(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_headers.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void RequestPrototype__headersSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
-    thisObject->m_headers.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue RequestPrototype__headersGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void RequestPrototype__headersSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
+      thisObject->m_headers.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue RequestPrototype__headersGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_headers.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__integrityGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17784,39 +19107,41 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__integrityGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(RequestPrototype__jsonCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(RequestPrototype__jsonCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
+        JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return RequestPrototype__getJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return RequestPrototype__getJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__methodGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17824,11 +19149,12 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__methodGetterWrap, (JSGlobalObject * l
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__modeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17836,11 +19162,12 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__modeGetterWrap, (JSGlobalObject * lex
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__redirectGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17848,11 +19175,12 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__redirectGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__referrerGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17860,11 +19188,12 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__referrerGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__referrerPolicyGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -17872,96 +19201,106 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__referrerPolicyGetterWrap, (JSGlobalOb
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__signalGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_signal.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        RequestPrototype__getSignal(thisObject->wrapped(), globalObject));
+        RequestPrototype__getSignal(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_signal.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void RequestPrototype__signalSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
-    thisObject->m_signal.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue RequestPrototype__signalGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void RequestPrototype__signalSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
+      thisObject->m_signal.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue RequestPrototype__signalGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_signal.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(RequestPrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(RequestPrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
+        JSRequest* thisObject = jsDynamicCast<JSRequest*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Request"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return RequestPrototype__getText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return RequestPrototype__getText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__urlGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_url.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        RequestPrototype__getUrl(thisObject->wrapped(), globalObject));
+        RequestPrototype__getUrl(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_url.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void RequestPrototype__urlSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
-    thisObject->m_url.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue RequestPrototype__urlGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void RequestPrototype__urlSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
+      thisObject->m_url.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue RequestPrototype__urlGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_url.get());
-}
+  }
+  
+  
 
 void JSRequestPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -17972,68 +19311,72 @@ void JSRequestPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* global
 
 extern "C" size_t Request__estimatedSize(void* ptr);
 
+
+
 void JSRequestConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSRequestPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "Request"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSRequestConstructor::JSRequestConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSRequestConstructor::JSRequestConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSRequestConstructor* JSRequestConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSRequestPrototype* prototype)
-{
+  }
+
+JSRequestConstructor* JSRequestConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSRequestPrototype* prototype) {
     JSRequestConstructor* ptr = new (NotNull, JSC::allocateCell<JSRequestConstructor>(vm)) JSRequestConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSRequestConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSRequestConstructor();
     Structure* structure = globalObject->JSRequestStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSRequestStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSRequestStructure()
+      );
     }
 
     void* ptr = RequestClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSRequest* instance = JSRequest::create(vm, globalObject, structure, ptr);
-    vm.heap.reportExtraMemoryAllocated(instance, Request__estimatedSize(instance->wrapped()));
+  vm.heap.reportExtraMemoryAllocated(instance, Request__estimatedSize(instance->wrapped()));
 
     return JSValue::encode(instance);
 }
 
 void JSRequestConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSRequestPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSRequestConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSRequestConstructor) };
 
-extern "C" EncodedJSValue Request__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue Request__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSRequestConstructor());
-}
+  }
 
 JSRequest::~JSRequest()
 {
@@ -18045,7 +19388,7 @@ void JSRequest::destroy(JSCell* cell)
 {
     static_cast<JSRequest*>(cell)->JSRequest::~JSRequest();
 }
-
+  
 const ClassInfo JSRequest::s_info = { "Request"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSRequest) };
 
 void JSRequest::finishCreation(VM& vm)
@@ -18054,38 +19397,37 @@ void JSRequest::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSRequest* JSRequest::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSRequest* ptr = new (NotNull, JSC::allocateCell<JSRequest>(vm)) JSRequest(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Request__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSRequest* JSRequest::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSRequest* ptr = new (NotNull, JSC::allocateCell<JSRequest>(vm)) JSRequest(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSRequest* object = JSC::jsDynamicCast<JSRequest*>(cell);
+extern "C" void* Request__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSRequest* object = JSC::jsDynamicCast<JSRequest*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Request__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSRequest* object = JSC::jsDynamicCast<JSRequest*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Request__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSRequest* object = JSC::jsDynamicCast<JSRequest*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Request__ptrOffset = JSRequest::offsetOfWrapped();
 
 void JSRequest::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -18100,7 +19442,7 @@ void JSRequest::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSRequest::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSRequestConstructor::create(vm, globalObject, WebCore::JSRequestConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSRequestPrototype*>(prototype));
+  return WebCore::JSRequestConstructor::create(vm, globalObject, WebCore::JSRequestConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSRequestPrototype*>(prototype));
 }
 
 JSObject* JSRequest::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -18108,13 +19450,12 @@ JSObject* JSRequest::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSRequestPrototype::create(vm, globalObject, JSRequestPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Request__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSRequestStructure();
-    JSRequest* instance = JSRequest::create(vm, globalObject, structure, ptr);
-    vm.heap.reportExtraMemoryAllocated(instance, Request__estimatedSize(ptr));
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Request__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSRequestStructure();
+  JSRequest* instance = JSRequest::create(vm, globalObject, structure, ptr);
+  vm.heap.reportExtraMemoryAllocated(instance, Request__estimatedSize(ptr));
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -18124,8 +19465,8 @@ void JSRequest::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
     if (auto* ptr = thisObject->wrapped()) {
-        visitor.reportExtraMemoryVisited(Request__estimatedSize(ptr));
-    }
+visitor.reportExtraMemoryVisited(Request__estimatedSize(ptr));
+}
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -18134,19 +19475,20 @@ DEFINE_VISIT_CHILDREN(JSRequest);
 template<typename Visitor>
 void JSRequest::visitAdditionalChildren(Visitor& visitor)
 {
-    JSRequest* thisObject = this;
+  JSRequest* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_body);
+    
+        visitor.append(thisObject->m_body);
     visitor.append(thisObject->m_headers);
     visitor.append(thisObject->m_signal);
     visitor.append(thisObject->m_url);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSRequest);
 
 template<typename Visitor>
-void JSRequest::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSRequest::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSRequest* thisObject = jsCast<JSRequest*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -18154,126 +19496,147 @@ void JSRequest::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSRequest);
-class JSResolveMessagePrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSResolveMessagePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSResolveMessagePrototype* ptr = new (NotNull, JSC::allocateCell<JSResolveMessagePrototype>(vm)) JSResolveMessagePrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSResolveMessagePrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSResolveMessagePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSResolveMessagePrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSResolveMessagePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSResolveMessagePrototype* ptr = new (NotNull, JSC::allocateCell<JSResolveMessagePrototype>(vm)) JSResolveMessagePrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSResolveMessagePrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSResolveMessagePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSResolveMessageConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSResolveMessageConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSResolveMessagePrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
+    public:
+        using Base = JSC::InternalFunction;
+        static JSResolveMessageConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSResolveMessagePrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSResolveMessageConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForResolveMessageConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResolveMessageConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForResolveMessageConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForResolveMessageConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSResolveMessagePrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSResolveMessageConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSResolveMessagePrototype* prototype);
+    };
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSResolveMessageConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForResolveMessageConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResolveMessageConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForResolveMessageConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForResolveMessageConstructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSResolveMessagePrototype* prototype);
+extern "C" void* ResolveMessageClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsResolveMessageConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSResolveMessageConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSResolveMessagePrototype* prototype);
-};
 
-extern "C" void* ResolveMessageClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsResolveMessageConstructor);
 
 extern "C" void ResolveMessageClass__finalize(void*);
 
+
 extern "C" EncodedJSValue ResolveMessagePrototype__toPrimitive(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResolveMessagePrototype__toPrimitiveCallback);
 
+
 extern "C" JSC::EncodedJSValue ResolveMessagePrototype__getCode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResolveMessagePrototype__codeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResolveMessagePrototype__getImportKind(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResolveMessagePrototype__importKindGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResolveMessagePrototype__getLevel(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResolveMessagePrototype__levelGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResolveMessagePrototype__getMessage(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResolveMessagePrototype__messageGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResolveMessagePrototype__getPosition(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResolveMessagePrototype__positionGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResolveMessagePrototype__getReferrer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResolveMessagePrototype__referrerGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResolveMessagePrototype__getSpecifier(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResolveMessagePrototype__specifierGetterWrap);
 
+
 extern "C" EncodedJSValue ResolveMessagePrototype__toJSON(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResolveMessagePrototype__toJSONCallback);
 
+
 extern "C" EncodedJSValue ResolveMessagePrototype__toString(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResolveMessagePrototype__toStringCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSResolveMessagePrototype, JSResolveMessagePrototype::Base);
 
-static const HashTableValue JSResolveMessagePrototypeTableValues[] = {
-    { "code"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__codeGetterWrap, 0 } },
-    { "importKind"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__importKindGetterWrap, 0 } },
-    { "level"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__levelGetterWrap, 0 } },
-    { "message"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__messageGetterWrap, 0 } },
-    { "position"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__positionGetterWrap, 0 } },
-    { "referrer"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__referrerGetterWrap, 0 } },
-    { "specifier"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__specifierGetterWrap, 0 } },
-    { "toJSON"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResolveMessagePrototype__toJSONCallback, 0 } },
-    { "toString"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResolveMessagePrototype__toStringCallback, 0 } }
+
+  static const HashTableValue JSResolveMessagePrototypeTableValues[] = {
+{ "code"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__codeGetterWrap, 0 } }  ,
+{ "importKind"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__importKindGetterWrap, 0 } }  ,
+{ "level"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__levelGetterWrap, 0 } }  ,
+{ "message"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__messageGetterWrap, 0 } }  ,
+{ "position"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__positionGetterWrap, 0 } }  ,
+{ "referrer"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__referrerGetterWrap, 0 } }  ,
+{ "specifier"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResolveMessagePrototype__specifierGetterWrap, 0 } }  ,
+{ "toJSON"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResolveMessagePrototype__toJSONCallback, 0 } }  ,
+{ "toString"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResolveMessagePrototype__toStringCallback, 0 } }
 };
 
+
+
 const ClassInfo JSResolveMessagePrototype::s_info = { "ResolveMessage"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSResolveMessagePrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsResolveMessageConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -18284,379 +19647,415 @@ JSC_DEFINE_CUSTOM_GETTER(jsResolveMessageConstructor, (JSGlobalObject * lexicalG
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for ResolveMessage"_s);
     return JSValue::encode(globalObject->JSResolveMessageConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(ResolveMessagePrototype__toPrimitiveCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSResolveMessage* thisObject = jsDynamicCast<JSResolveMessage*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(ResolveMessagePrototype__toPrimitiveCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ResolveMessage"_s);
-        return JSValue::encode({});
-    }
+        JSResolveMessage* thisObject = jsDynamicCast<JSResolveMessage*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ResolveMessage"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    return ResolveMessagePrototype__toPrimitive(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return ResolveMessagePrototype__toPrimitive(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ResolveMessagePrototype__codeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_code.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResolveMessagePrototype__getCode(thisObject->wrapped(), globalObject));
+        ResolveMessagePrototype__getCode(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_code.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResolveMessagePrototype__codeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    thisObject->m_code.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResolveMessagePrototype__codeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResolveMessagePrototype__codeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
+      thisObject->m_code.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResolveMessagePrototype__codeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_code.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(ResolveMessagePrototype__importKindGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_importKind.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResolveMessagePrototype__getImportKind(thisObject->wrapped(), globalObject));
+        ResolveMessagePrototype__getImportKind(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_importKind.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResolveMessagePrototype__importKindSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    thisObject->m_importKind.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResolveMessagePrototype__importKindGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResolveMessagePrototype__importKindSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
+      thisObject->m_importKind.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResolveMessagePrototype__importKindGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_importKind.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(ResolveMessagePrototype__levelGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_level.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResolveMessagePrototype__getLevel(thisObject->wrapped(), globalObject));
+        ResolveMessagePrototype__getLevel(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_level.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResolveMessagePrototype__levelSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    thisObject->m_level.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResolveMessagePrototype__levelGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResolveMessagePrototype__levelSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
+      thisObject->m_level.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResolveMessagePrototype__levelGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_level.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(ResolveMessagePrototype__messageGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_message.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResolveMessagePrototype__getMessage(thisObject->wrapped(), globalObject));
+        ResolveMessagePrototype__getMessage(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_message.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResolveMessagePrototype__messageSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    thisObject->m_message.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResolveMessagePrototype__messageGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResolveMessagePrototype__messageSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
+      thisObject->m_message.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResolveMessagePrototype__messageGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_message.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(ResolveMessagePrototype__positionGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_position.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResolveMessagePrototype__getPosition(thisObject->wrapped(), globalObject));
+        ResolveMessagePrototype__getPosition(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_position.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResolveMessagePrototype__positionSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    thisObject->m_position.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResolveMessagePrototype__positionGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResolveMessagePrototype__positionSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
+      thisObject->m_position.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResolveMessagePrototype__positionGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_position.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(ResolveMessagePrototype__referrerGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_referrer.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResolveMessagePrototype__getReferrer(thisObject->wrapped(), globalObject));
+        ResolveMessagePrototype__getReferrer(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_referrer.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResolveMessagePrototype__referrerSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    thisObject->m_referrer.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResolveMessagePrototype__referrerGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResolveMessagePrototype__referrerSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
+      thisObject->m_referrer.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResolveMessagePrototype__referrerGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_referrer.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(ResolveMessagePrototype__specifierGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_specifier.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResolveMessagePrototype__getSpecifier(thisObject->wrapped(), globalObject));
+        ResolveMessagePrototype__getSpecifier(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_specifier.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResolveMessagePrototype__specifierSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
-    thisObject->m_specifier.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResolveMessagePrototype__specifierGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResolveMessagePrototype__specifierSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
+      thisObject->m_specifier.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResolveMessagePrototype__specifierGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResolveMessage*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_specifier.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(ResolveMessagePrototype__toJSONCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ResolveMessagePrototype__toJSONCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSResolveMessage* thisObject = jsDynamicCast<JSResolveMessage*>(callFrame->thisValue());
+        JSResolveMessage* thisObject = jsDynamicCast<JSResolveMessage*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ResolveMessage"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ResolveMessage"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ResolveMessagePrototype__toJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ResolveMessagePrototype__toJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ResolveMessagePrototype__toStringCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ResolveMessagePrototype__toStringCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSResolveMessage* thisObject = jsDynamicCast<JSResolveMessage*>(callFrame->thisValue());
 
-    JSResolveMessage* thisObject = jsDynamicCast<JSResolveMessage*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ResolveMessage"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ResolveMessage"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ResolveMessagePrototype__toString(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ResolveMessagePrototype__toString(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSResolveMessagePrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
     reifyStaticProperties(vm, JSResolveMessage::info(), JSResolveMessagePrototypeTableValues, *this);
     this->putDirect(vm, vm.propertyNames->toPrimitiveSymbol, JSFunction::create(vm, globalObject, 1, String("toPrimitive"_s), ResolveMessagePrototype__toPrimitiveCallback, ImplementationVisibility::Public), PropertyAttribute::ReadOnly | PropertyAttribute::DontEnum | 0);
-    this->putDirect(vm, vm.propertyNames->name, jsString(vm, String("ResolveMessage"_s)), PropertyAttribute::ReadOnly | 0);
+      this->putDirect(vm, vm.propertyNames->name, jsString(vm, String("ResolveMessage"_s)), PropertyAttribute::ReadOnly | 0);
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
 void JSResolveMessageConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSResolveMessagePrototype* prototype)
 {
     Base::finishCreation(vm, 0, "ResolveMessage"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSResolveMessageConstructor::JSResolveMessageConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSResolveMessageConstructor::JSResolveMessageConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSResolveMessageConstructor* JSResolveMessageConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSResolveMessagePrototype* prototype)
-{
+  }
+
+JSResolveMessageConstructor* JSResolveMessageConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSResolveMessagePrototype* prototype) {
     JSResolveMessageConstructor* ptr = new (NotNull, JSC::allocateCell<JSResolveMessageConstructor>(vm)) JSResolveMessageConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSResolveMessageConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSResolveMessageConstructor();
     Structure* structure = globalObject->JSResolveMessageStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSResolveMessageStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSResolveMessageStructure()
+      );
     }
 
     void* ptr = ResolveMessageClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSResolveMessage* instance = JSResolveMessage::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSResolveMessageConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSResolveMessagePrototype* prototype)
 {
+
 }
 
 const ClassInfo JSResolveMessageConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSResolveMessageConstructor) };
 
-extern "C" EncodedJSValue ResolveMessage__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue ResolveMessage__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSResolveMessageConstructor());
-}
+  }
 
 JSResolveMessage::~JSResolveMessage()
 {
@@ -18668,7 +20067,7 @@ void JSResolveMessage::destroy(JSCell* cell)
 {
     static_cast<JSResolveMessage*>(cell)->JSResolveMessage::~JSResolveMessage();
 }
-
+  
 const ClassInfo JSResolveMessage::s_info = { "ResolveMessage"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSResolveMessage) };
 
 void JSResolveMessage::finishCreation(VM& vm)
@@ -18677,38 +20076,37 @@ void JSResolveMessage::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSResolveMessage* JSResolveMessage::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSResolveMessage* ptr = new (NotNull, JSC::allocateCell<JSResolveMessage>(vm)) JSResolveMessage(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* ResolveMessage__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSResolveMessage* JSResolveMessage::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSResolveMessage* ptr = new (NotNull, JSC::allocateCell<JSResolveMessage>(vm)) JSResolveMessage(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSResolveMessage* object = JSC::jsDynamicCast<JSResolveMessage*>(cell);
+extern "C" void* ResolveMessage__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSResolveMessage* object = JSC::jsDynamicCast<JSResolveMessage*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool ResolveMessage__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSResolveMessage* object = JSC::jsDynamicCast<JSResolveMessage*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool ResolveMessage__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSResolveMessage* object = JSC::jsDynamicCast<JSResolveMessage*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t ResolveMessage__ptrOffset = JSResolveMessage::offsetOfWrapped();
 
 void JSResolveMessage::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -18723,7 +20121,7 @@ void JSResolveMessage::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSResolveMessage::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSResolveMessageConstructor::create(vm, globalObject, WebCore::JSResolveMessageConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSResolveMessagePrototype*>(prototype));
+  return WebCore::JSResolveMessageConstructor::create(vm, globalObject, WebCore::JSResolveMessageConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSResolveMessagePrototype*>(prototype));
 }
 
 JSObject* JSResolveMessage::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -18731,13 +20129,12 @@ JSObject* JSResolveMessage::createPrototype(VM& vm, JSDOMGlobalObject* globalObj
     return JSResolveMessagePrototype::create(vm, globalObject, JSResolveMessagePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue ResolveMessage__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSResolveMessageStructure();
-    JSResolveMessage* instance = JSResolveMessage::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue ResolveMessage__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSResolveMessageStructure();
+  JSResolveMessage* instance = JSResolveMessage::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -18746,7 +20143,7 @@ void JSResolveMessage::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -18755,22 +20152,23 @@ DEFINE_VISIT_CHILDREN(JSResolveMessage);
 template<typename Visitor>
 void JSResolveMessage::visitAdditionalChildren(Visitor& visitor)
 {
-    JSResolveMessage* thisObject = this;
+  JSResolveMessage* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_code);
+    
+        visitor.append(thisObject->m_code);
     visitor.append(thisObject->m_importKind);
     visitor.append(thisObject->m_level);
     visitor.append(thisObject->m_message);
     visitor.append(thisObject->m_position);
     visitor.append(thisObject->m_referrer);
     visitor.append(thisObject->m_specifier);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSResolveMessage);
 
 template<typename Visitor>
-void JSResolveMessage::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSResolveMessage::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSResolveMessage* thisObject = jsCast<JSResolveMessage*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -18778,147 +20176,173 @@ void JSResolveMessage::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSResolveMessage);
-class JSResponsePrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSResponsePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSResponsePrototype* ptr = new (NotNull, JSC::allocateCell<JSResponsePrototype>(vm)) JSResponsePrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSResponsePrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSResponsePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSResponsePrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSResponsePrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSResponsePrototype* ptr = new (NotNull, JSC::allocateCell<JSResponsePrototype>(vm)) JSResponsePrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSResponsePrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSResponsePrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSResponseConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSResponseConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSResponsePrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
+    public:
+        using Base = JSC::InternalFunction;
+        static JSResponseConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSResponsePrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSResponseConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForResponseConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResponseConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForResponseConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForResponseConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSResponsePrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSResponseConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSResponsePrototype* prototype);
+    };
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSResponseConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForResponseConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResponseConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForResponseConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForResponseConstructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSResponsePrototype* prototype);
+extern "C" void* ResponseClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsResponseConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSResponseConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSResponsePrototype* prototype);
-};
 
-extern "C" void* ResponseClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsResponseConstructor);
 
 extern "C" void ResponseClass__finalize(void*);
 
+
 extern "C" EncodedJSValue ResponsePrototype__getArrayBuffer(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResponsePrototype__arrayBufferCallback);
 
+
 extern "C" EncodedJSValue ResponsePrototype__getBlob(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResponsePrototype__blobCallback);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getBody(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__bodyGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getBodyUsed(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__bodyUsedGetterWrap);
 
+
 extern "C" EncodedJSValue ResponsePrototype__doClone(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResponsePrototype__cloneCallback);
 
+
 extern "C" EncodedJSValue ResponsePrototype__getFormData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResponsePrototype__formDataCallback);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getHeaders(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__headersGetterWrap);
 
+
 extern "C" EncodedJSValue ResponsePrototype__getJSON(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResponsePrototype__jsonCallback);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getOK(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__okGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getRedirected(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__redirectedGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getStatus(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__statusGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getStatusText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__statusTextGetterWrap);
 
+
 extern "C" EncodedJSValue ResponsePrototype__getText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ResponsePrototype__textCallback);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getResponseType(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__typeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ResponsePrototype__getURL(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ResponsePrototype__urlGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSResponsePrototype, JSResponsePrototype::Base);
 
-static const HashTableValue JSResponsePrototypeTableValues[] = {
-    { "arrayBuffer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__arrayBufferCallback, 0 } },
-    { "blob"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__blobCallback, 0 } },
-    { "body"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__bodyGetterWrap, 0 } },
-    { "bodyUsed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__bodyUsedGetterWrap, 0 } },
-    { "clone"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__cloneCallback, 1 } },
-    { "formData"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__formDataCallback, 0 } },
-    { "headers"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__headersGetterWrap, 0 } },
-    { "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__jsonCallback, 0 } },
-    { "ok"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__okGetterWrap, 0 } },
-    { "redirected"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__redirectedGetterWrap, 0 } },
-    { "status"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__statusGetterWrap, 0 } },
-    { "statusText"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__statusTextGetterWrap, 0 } },
-    { "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__textCallback, 0 } },
-    { "type"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__typeGetterWrap, 0 } },
-    { "url"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__urlGetterWrap, 0 } }
+
+  static const HashTableValue JSResponsePrototypeTableValues[] = {
+{ "arrayBuffer"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__arrayBufferCallback, 0 } }  ,
+{ "blob"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__blobCallback, 0 } }  ,
+{ "body"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__bodyGetterWrap, 0 } }  ,
+{ "bodyUsed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__bodyUsedGetterWrap, 0 } }  ,
+{ "clone"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__cloneCallback, 1 } }  ,
+{ "formData"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__formDataCallback, 0 } }  ,
+{ "headers"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__headersGetterWrap, 0 } }  ,
+{ "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__jsonCallback, 0 } }  ,
+{ "ok"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__okGetterWrap, 0 } }  ,
+{ "redirected"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__redirectedGetterWrap, 0 } }  ,
+{ "status"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__statusGetterWrap, 0 } }  ,
+{ "statusText"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__statusTextGetterWrap, 0 } }  ,
+{ "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponsePrototype__textCallback, 0 } }  ,
+{ "type"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__typeGetterWrap, 0 } }  ,
+{ "url"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ResponsePrototype__urlGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSResponsePrototype::s_info = { "Response"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSResponsePrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsResponseConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -18929,99 +20353,107 @@ JSC_DEFINE_CUSTOM_GETTER(jsResponseConstructor, (JSGlobalObject * lexicalGlobalO
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Response"_s);
     return JSValue::encode(globalObject->JSResponseConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__arrayBufferCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__arrayBufferCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
-        return JSValue::encode({});
-    }
+        JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return ResponsePrototype__getArrayBuffer(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ResponsePrototype__getArrayBuffer(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__blobCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__blobCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
 
-    JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ResponsePrototype__getBlob(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ResponsePrototype__getBlob(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__bodyGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_body.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResponsePrototype__getBody(thisObject->wrapped(), globalObject));
+        ResponsePrototype__getBody(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_body.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResponsePrototype__bodySetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
-    thisObject->m_body.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResponsePrototype__bodyGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResponsePrototype__bodySetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
+      thisObject->m_body.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResponsePrototype__bodyGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_body.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__bodyUsedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -19029,126 +20461,134 @@ JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__bodyUsedGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__cloneCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__cloneCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
+        JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ResponsePrototype__doClone(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ResponsePrototype__doClone(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__formDataCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__formDataCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
 
-    JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ResponsePrototype__getFormData(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ResponsePrototype__getFormData(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__headersGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_headers.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResponsePrototype__getHeaders(thisObject->wrapped(), globalObject));
+        ResponsePrototype__getHeaders(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_headers.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResponsePrototype__headersSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
-    thisObject->m_headers.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResponsePrototype__headersGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResponsePrototype__headersSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
+      thisObject->m_headers.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResponsePrototype__headersGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_headers.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__jsonCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__jsonCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
+        JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return ResponsePrototype__getJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return ResponsePrototype__getJSON(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__okGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -19156,11 +20596,12 @@ JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__okGetterWrap, (JSGlobalObject * lexi
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__redirectedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -19168,11 +20609,12 @@ JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__redirectedGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__statusGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -19180,70 +20622,76 @@ JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__statusGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__statusTextGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_statusText.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResponsePrototype__getStatusText(thisObject->wrapped(), globalObject));
+        ResponsePrototype__getStatusText(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_statusText.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResponsePrototype__statusTextSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
-    thisObject->m_statusText.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResponsePrototype__statusTextGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResponsePrototype__statusTextSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
+      thisObject->m_statusText.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResponsePrototype__statusTextGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_statusText.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ResponsePrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
+        JSResponse* thisObject = jsDynamicCast<JSResponse*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Response"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return ResponsePrototype__getText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return ResponsePrototype__getText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__typeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -19251,37 +20699,42 @@ JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__typeGetterWrap, (JSGlobalObject * le
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(ResponsePrototype__urlGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSResponse* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_url.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ResponsePrototype__getURL(thisObject->wrapped(), globalObject));
+        ResponsePrototype__getURL(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_url.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ResponsePrototype__urlSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
-    thisObject->m_url.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ResponsePrototype__urlGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ResponsePrototype__urlSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
+      thisObject->m_url.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ResponsePrototype__urlGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSResponse*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_url.get());
-}
+  }
+  
+  
 
 void JSResponsePrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -19295,12 +20748,13 @@ extern "C" JSC_DECLARE_HOST_FUNCTION(ResponseClass__constructError);
 extern "C" JSC_DECLARE_HOST_FUNCTION(ResponseClass__constructJSON);
 extern "C" JSC_DECLARE_HOST_FUNCTION(ResponseClass__constructRedirect);
 
-static const HashTableValue JSResponseConstructorTableValues[] = {
-    { "error"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponseClass__constructError, 0 } },
-    { "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponseClass__constructJSON, 0 } },
-    { "redirect"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponseClass__constructRedirect, 0 } }
+  static const HashTableValue JSResponseConstructorTableValues[] = {
+{ "error"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponseClass__constructError, 0 } }  ,
+{ "json"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponseClass__constructJSON, 0 } }  ,
+{ "redirect"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ResponseClass__constructRedirect, 0 } }
 };
 
+
 void JSResponseConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSResponsePrototype* prototype)
 {
     Base::finishCreation(vm, 0, "Response"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -19309,60 +20763,62 @@ void JSResponseConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalOb
     ASSERT(inherits(info()));
 }
 
-JSResponseConstructor::JSResponseConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSResponseConstructor::JSResponseConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSResponseConstructor* JSResponseConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSResponsePrototype* prototype)
-{
+  }
+
+JSResponseConstructor* JSResponseConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSResponsePrototype* prototype) {
     JSResponseConstructor* ptr = new (NotNull, JSC::allocateCell<JSResponseConstructor>(vm)) JSResponseConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSResponseConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSResponseConstructor();
     Structure* structure = globalObject->JSResponseStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSResponseStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSResponseStructure()
+      );
     }
 
     void* ptr = ResponseClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSResponse* instance = JSResponse::create(vm, globalObject, structure, ptr);
-    vm.heap.reportExtraMemoryAllocated(instance, Response__estimatedSize(instance->wrapped()));
+  vm.heap.reportExtraMemoryAllocated(instance, Response__estimatedSize(instance->wrapped()));
 
     return JSValue::encode(instance);
 }
 
 void JSResponseConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSResponsePrototype* prototype)
 {
+
 }
 
 const ClassInfo JSResponseConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSResponseConstructor) };
 
-extern "C" EncodedJSValue Response__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue Response__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSResponseConstructor());
-}
+  }
 
 JSResponse::~JSResponse()
 {
@@ -19374,7 +20830,7 @@ void JSResponse::destroy(JSCell* cell)
 {
     static_cast<JSResponse*>(cell)->JSResponse::~JSResponse();
 }
-
+  
 const ClassInfo JSResponse::s_info = { "Response"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSResponse) };
 
 void JSResponse::finishCreation(VM& vm)
@@ -19383,38 +20839,37 @@ void JSResponse::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSResponse* JSResponse::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSResponse* ptr = new (NotNull, JSC::allocateCell<JSResponse>(vm)) JSResponse(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Response__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSResponse* JSResponse::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSResponse* ptr = new (NotNull, JSC::allocateCell<JSResponse>(vm)) JSResponse(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSResponse* object = JSC::jsDynamicCast<JSResponse*>(cell);
+extern "C" void* Response__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSResponse* object = JSC::jsDynamicCast<JSResponse*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Response__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSResponse* object = JSC::jsDynamicCast<JSResponse*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Response__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSResponse* object = JSC::jsDynamicCast<JSResponse*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Response__ptrOffset = JSResponse::offsetOfWrapped();
 
 void JSResponse::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -19429,7 +20884,7 @@ void JSResponse::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSResponse::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSResponseConstructor::create(vm, globalObject, WebCore::JSResponseConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSResponsePrototype*>(prototype));
+  return WebCore::JSResponseConstructor::create(vm, globalObject, WebCore::JSResponseConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSResponsePrototype*>(prototype));
 }
 
 JSObject* JSResponse::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -19437,13 +20892,12 @@ JSObject* JSResponse::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSResponsePrototype::create(vm, globalObject, JSResponsePrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Response__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSResponseStructure();
-    JSResponse* instance = JSResponse::create(vm, globalObject, structure, ptr);
-    vm.heap.reportExtraMemoryAllocated(instance, Response__estimatedSize(ptr));
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Response__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSResponseStructure();
+  JSResponse* instance = JSResponse::create(vm, globalObject, structure, ptr);
+  vm.heap.reportExtraMemoryAllocated(instance, Response__estimatedSize(ptr));
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -19453,8 +20907,8 @@ void JSResponse::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
     if (auto* ptr = thisObject->wrapped()) {
-        visitor.reportExtraMemoryVisited(Response__estimatedSize(ptr));
-    }
+visitor.reportExtraMemoryVisited(Response__estimatedSize(ptr));
+}
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -19463,19 +20917,20 @@ DEFINE_VISIT_CHILDREN(JSResponse);
 template<typename Visitor>
 void JSResponse::visitAdditionalChildren(Visitor& visitor)
 {
-    JSResponse* thisObject = this;
+  JSResponse* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_body);
+    
+        visitor.append(thisObject->m_body);
     visitor.append(thisObject->m_headers);
     visitor.append(thisObject->m_statusText);
     visitor.append(thisObject->m_url);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSResponse);
 
 template<typename Visitor>
-void JSResponse::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSResponse::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSResponse* thisObject = jsCast<JSResponse*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -19483,99 +20938,113 @@ void JSResponse::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSResponse);
-class JSSHA1Prototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSSHA1Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSSHA1Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA1Prototype>(vm)) JSSHA1Prototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA1Prototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSSHA1Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSSHA1Prototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSSHA1Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSSHA1Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA1Prototype>(vm)) JSSHA1Prototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA1Prototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSSHA1Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSSHA1Constructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSSHA1Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA1Prototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSSHA1Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA1Prototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA1Constructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA1Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA1Constructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA1Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA1Constructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA1Prototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSSHA1Constructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA1Prototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA1Constructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA1Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA1Constructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA1Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA1Constructor = std::forward<decltype(space)>(space); });
-    }
+extern "C" void* SHA1Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsSHA1Constructor);
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA1Prototype* prototype);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSSHA1Constructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA1Prototype* prototype);
-};
-
-extern "C" void* SHA1Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsSHA1Constructor);
 
 extern "C" void SHA1Class__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue SHA1Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SHA1Prototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue SHA1Prototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA1Prototype__digestCallback);
 
+
 extern "C" EncodedJSValue SHA1Prototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA1Prototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA1Prototype, JSSHA1Prototype::Base);
 
-static const HashTableValue JSSHA1PrototypeTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA1Prototype__byteLengthGetterWrap, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA1Prototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA1Prototype__updateCallback, 1 } }
+
+  static const HashTableValue JSSHA1PrototypeTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA1Prototype__byteLengthGetterWrap, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA1Prototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA1Prototype__updateCallback, 1 } }
 };
 
+
+
 const ClassInfo JSSHA1Prototype::s_info = { "SHA1"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA1Prototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsSHA1Constructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -19586,12 +21055,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsSHA1Constructor, (JSGlobalObject * lexicalGlobalObjec
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for SHA1"_s);
     return JSValue::encode(globalObject->JSSHA1Constructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(SHA1Prototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSHA1* thisObject = jsCast<JSSHA1*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -19599,62 +21070,65 @@ JSC_DEFINE_CUSTOM_GETTER(SHA1Prototype__byteLengthGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(SHA1Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SHA1Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSHA1* thisObject = jsDynamicCast<JSSHA1*>(callFrame->thisValue());
+        JSSHA1* thisObject = jsDynamicCast<JSSHA1*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA1"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA1"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return SHA1Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return SHA1Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(SHA1Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(SHA1Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSSHA1* thisObject = jsDynamicCast<JSSHA1*>(callFrame->thisValue());
 
-    JSSHA1* thisObject = jsDynamicCast<JSSHA1*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA1"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA1"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA1Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return SHA1Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSSHA1Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -19666,11 +21140,12 @@ void JSSHA1Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObj
 extern "C" JSC_DECLARE_CUSTOM_GETTER(SHA1Class__getByteLengthStatic);
 extern "C" JSC_DECLARE_HOST_FUNCTION(SHA1Class__hash);
 
-static const HashTableValue JSSHA1ConstructorTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA1Class__getByteLengthStatic, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA1Class__hash, 2 } }
+  static const HashTableValue JSSHA1ConstructorTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA1Class__getByteLengthStatic, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA1Class__hash, 2 } }
 };
 
+
 void JSSHA1Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA1Prototype* prototype)
 {
     Base::finishCreation(vm, 0, "SHA1"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -19679,59 +21154,62 @@ void JSSHA1Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject
     ASSERT(inherits(info()));
 }
 
-JSSHA1Constructor::JSSHA1Constructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSSHA1Constructor::JSSHA1Constructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSSHA1Constructor* JSSHA1Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA1Prototype* prototype)
-{
+  }
+
+JSSHA1Constructor* JSSHA1Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA1Prototype* prototype) {
     JSSHA1Constructor* ptr = new (NotNull, JSC::allocateCell<JSSHA1Constructor>(vm)) JSSHA1Constructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSSHA1Constructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSSHA1Constructor();
     Structure* structure = globalObject->JSSHA1Structure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSSHA1Structure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSSHA1Structure()
+      );
     }
 
     void* ptr = SHA1Class__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSSHA1* instance = JSSHA1::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSSHA1Constructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA1Prototype* prototype)
 {
+
 }
 
 const ClassInfo JSSHA1Constructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA1Constructor) };
 
-extern "C" EncodedJSValue SHA1__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue SHA1__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSSHA1Constructor());
-}
+  }
 
 JSSHA1::~JSSHA1()
 {
@@ -19743,7 +21221,7 @@ void JSSHA1::destroy(JSCell* cell)
 {
     static_cast<JSSHA1*>(cell)->JSSHA1::~JSSHA1();
 }
-
+  
 const ClassInfo JSSHA1::s_info = { "SHA1"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA1) };
 
 void JSSHA1::finishCreation(VM& vm)
@@ -19752,38 +21230,37 @@ void JSSHA1::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSSHA1* JSSHA1::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSSHA1* ptr = new (NotNull, JSC::allocateCell<JSSHA1>(vm)) JSSHA1(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* SHA1__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSSHA1* JSSHA1::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSSHA1* ptr = new (NotNull, JSC::allocateCell<JSSHA1>(vm)) JSSHA1(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSSHA1* object = JSC::jsDynamicCast<JSSHA1*>(cell);
+extern "C" void* SHA1__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSSHA1* object = JSC::jsDynamicCast<JSSHA1*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool SHA1__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSSHA1* object = JSC::jsDynamicCast<JSSHA1*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool SHA1__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSSHA1* object = JSC::jsDynamicCast<JSSHA1*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t SHA1__ptrOffset = JSSHA1::offsetOfWrapped();
 
 void JSSHA1::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -19798,7 +21275,7 @@ void JSSHA1::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSSHA1::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSSHA1Constructor::create(vm, globalObject, WebCore::JSSHA1Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA1Prototype*>(prototype));
+  return WebCore::JSSHA1Constructor::create(vm, globalObject, WebCore::JSSHA1Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA1Prototype*>(prototype));
 }
 
 JSObject* JSSHA1::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -19806,107 +21283,120 @@ JSObject* JSSHA1::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSSHA1Prototype::create(vm, globalObject, JSSHA1Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue SHA1__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSSHA1Structure();
-    JSSHA1* instance = JSSHA1::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSSHA224Prototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSSHA224Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSSHA224Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA224Prototype>(vm)) JSSHA224Prototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA224Prototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSSHA224Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue SHA1__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSSHA1Structure();
+  JSSHA1* instance = JSSHA1::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSSHA224Prototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSSHA224Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSSHA224Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA224Prototype>(vm)) JSSHA224Prototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA224Prototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSSHA224Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSSHA224Constructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSSHA224Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA224Prototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
+    public:
+        using Base = JSC::InternalFunction;
+        static JSSHA224Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA224Prototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA224Constructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA224Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA224Constructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA224Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA224Constructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA224Prototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSSHA224Constructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA224Prototype* prototype);
+    };
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA224Constructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA224Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA224Constructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA224Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA224Constructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA224Prototype* prototype);
+extern "C" void* SHA224Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsSHA224Constructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSSHA224Constructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA224Prototype* prototype);
-};
 
-extern "C" void* SHA224Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsSHA224Constructor);
 
 extern "C" void SHA224Class__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue SHA224Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SHA224Prototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue SHA224Prototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA224Prototype__digestCallback);
 
+
 extern "C" EncodedJSValue SHA224Prototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA224Prototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA224Prototype, JSSHA224Prototype::Base);
 
-static const HashTableValue JSSHA224PrototypeTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA224Prototype__byteLengthGetterWrap, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA224Prototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA224Prototype__updateCallback, 1 } }
+
+  static const HashTableValue JSSHA224PrototypeTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA224Prototype__byteLengthGetterWrap, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA224Prototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA224Prototype__updateCallback, 1 } }
 };
 
+
+
 const ClassInfo JSSHA224Prototype::s_info = { "SHA224"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA224Prototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsSHA224Constructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -19917,12 +21407,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsSHA224Constructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for SHA224"_s);
     return JSValue::encode(globalObject->JSSHA224Constructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(SHA224Prototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSHA224* thisObject = jsCast<JSSHA224*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -19930,62 +21422,65 @@ JSC_DEFINE_CUSTOM_GETTER(SHA224Prototype__byteLengthGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(SHA224Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SHA224Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSHA224* thisObject = jsDynamicCast<JSSHA224*>(callFrame->thisValue());
+        JSSHA224* thisObject = jsDynamicCast<JSSHA224*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA224"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA224"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return SHA224Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return SHA224Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(SHA224Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(SHA224Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSSHA224* thisObject = jsDynamicCast<JSSHA224*>(callFrame->thisValue());
 
-    JSSHA224* thisObject = jsDynamicCast<JSSHA224*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA224"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA224"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA224Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return SHA224Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSSHA224Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -19997,11 +21492,12 @@ void JSSHA224Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalO
 extern "C" JSC_DECLARE_CUSTOM_GETTER(SHA224Class__getByteLengthStatic);
 extern "C" JSC_DECLARE_HOST_FUNCTION(SHA224Class__hash);
 
-static const HashTableValue JSSHA224ConstructorTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA224Class__getByteLengthStatic, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA224Class__hash, 2 } }
+  static const HashTableValue JSSHA224ConstructorTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA224Class__getByteLengthStatic, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA224Class__hash, 2 } }
 };
 
+
 void JSSHA224Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA224Prototype* prototype)
 {
     Base::finishCreation(vm, 0, "SHA224"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -20010,59 +21506,62 @@ void JSSHA224Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObje
     ASSERT(inherits(info()));
 }
 
-JSSHA224Constructor::JSSHA224Constructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSSHA224Constructor::JSSHA224Constructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSSHA224Constructor* JSSHA224Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA224Prototype* prototype)
-{
+  }
+
+JSSHA224Constructor* JSSHA224Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA224Prototype* prototype) {
     JSSHA224Constructor* ptr = new (NotNull, JSC::allocateCell<JSSHA224Constructor>(vm)) JSSHA224Constructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSSHA224Constructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSSHA224Constructor();
     Structure* structure = globalObject->JSSHA224Structure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSSHA224Structure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSSHA224Structure()
+      );
     }
 
     void* ptr = SHA224Class__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSSHA224* instance = JSSHA224::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSSHA224Constructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA224Prototype* prototype)
 {
+
 }
 
 const ClassInfo JSSHA224Constructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA224Constructor) };
 
-extern "C" EncodedJSValue SHA224__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue SHA224__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSSHA224Constructor());
-}
+  }
 
 JSSHA224::~JSSHA224()
 {
@@ -20074,7 +21573,7 @@ void JSSHA224::destroy(JSCell* cell)
 {
     static_cast<JSSHA224*>(cell)->JSSHA224::~JSSHA224();
 }
-
+  
 const ClassInfo JSSHA224::s_info = { "SHA224"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA224) };
 
 void JSSHA224::finishCreation(VM& vm)
@@ -20083,38 +21582,37 @@ void JSSHA224::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSSHA224* JSSHA224::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSSHA224* ptr = new (NotNull, JSC::allocateCell<JSSHA224>(vm)) JSSHA224(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* SHA224__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSSHA224* JSSHA224::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSSHA224* ptr = new (NotNull, JSC::allocateCell<JSSHA224>(vm)) JSSHA224(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSSHA224* object = JSC::jsDynamicCast<JSSHA224*>(cell);
+extern "C" void* SHA224__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSSHA224* object = JSC::jsDynamicCast<JSSHA224*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool SHA224__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSSHA224* object = JSC::jsDynamicCast<JSSHA224*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool SHA224__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSSHA224* object = JSC::jsDynamicCast<JSSHA224*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t SHA224__ptrOffset = JSSHA224::offsetOfWrapped();
 
 void JSSHA224::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -20129,7 +21627,7 @@ void JSSHA224::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSSHA224::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSSHA224Constructor::create(vm, globalObject, WebCore::JSSHA224Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA224Prototype*>(prototype));
+  return WebCore::JSSHA224Constructor::create(vm, globalObject, WebCore::JSSHA224Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA224Prototype*>(prototype));
 }
 
 JSObject* JSSHA224::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -20137,107 +21635,120 @@ JSObject* JSSHA224::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSSHA224Prototype::create(vm, globalObject, JSSHA224Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue SHA224__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSSHA224Structure();
-    JSSHA224* instance = JSSHA224::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSSHA256Prototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSSHA256Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSSHA256Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA256Prototype>(vm)) JSSHA256Prototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA256Prototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSSHA256Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue SHA224__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSSHA224Structure();
+  JSSHA224* instance = JSSHA224::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSSHA256Prototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSSHA256Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSSHA256Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA256Prototype>(vm)) JSSHA256Prototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA256Prototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSSHA256Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSSHA256Constructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSSHA256Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA256Prototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
+    public:
+        using Base = JSC::InternalFunction;
+        static JSSHA256Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA256Prototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA256Constructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA256Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA256Constructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA256Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA256Constructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA256Prototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSSHA256Constructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA256Prototype* prototype);
+    };
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA256Constructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA256Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA256Constructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA256Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA256Constructor = std::forward<decltype(space)>(space); });
-    }
-
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA256Prototype* prototype);
+extern "C" void* SHA256Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsSHA256Constructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSSHA256Constructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA256Prototype* prototype);
-};
 
-extern "C" void* SHA256Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsSHA256Constructor);
 
 extern "C" void SHA256Class__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue SHA256Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SHA256Prototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue SHA256Prototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA256Prototype__digestCallback);
 
+
 extern "C" EncodedJSValue SHA256Prototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA256Prototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA256Prototype, JSSHA256Prototype::Base);
 
-static const HashTableValue JSSHA256PrototypeTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA256Prototype__byteLengthGetterWrap, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA256Prototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA256Prototype__updateCallback, 1 } }
+
+  static const HashTableValue JSSHA256PrototypeTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA256Prototype__byteLengthGetterWrap, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA256Prototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA256Prototype__updateCallback, 1 } }
 };
 
+
+
 const ClassInfo JSSHA256Prototype::s_info = { "SHA256"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA256Prototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsSHA256Constructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -20248,12 +21759,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsSHA256Constructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for SHA256"_s);
     return JSValue::encode(globalObject->JSSHA256Constructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(SHA256Prototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSHA256* thisObject = jsCast<JSSHA256*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -20261,62 +21774,65 @@ JSC_DEFINE_CUSTOM_GETTER(SHA256Prototype__byteLengthGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(SHA256Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SHA256Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSHA256* thisObject = jsDynamicCast<JSSHA256*>(callFrame->thisValue());
+        JSSHA256* thisObject = jsDynamicCast<JSSHA256*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA256"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA256"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return SHA256Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return SHA256Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(SHA256Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(SHA256Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSSHA256* thisObject = jsDynamicCast<JSSHA256*>(callFrame->thisValue());
 
-    JSSHA256* thisObject = jsDynamicCast<JSSHA256*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA256"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA256"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA256Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return SHA256Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSSHA256Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -20328,11 +21844,12 @@ void JSSHA256Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalO
 extern "C" JSC_DECLARE_CUSTOM_GETTER(SHA256Class__getByteLengthStatic);
 extern "C" JSC_DECLARE_HOST_FUNCTION(SHA256Class__hash);
 
-static const HashTableValue JSSHA256ConstructorTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA256Class__getByteLengthStatic, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA256Class__hash, 2 } }
+  static const HashTableValue JSSHA256ConstructorTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA256Class__getByteLengthStatic, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA256Class__hash, 2 } }
 };
 
+
 void JSSHA256Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA256Prototype* prototype)
 {
     Base::finishCreation(vm, 0, "SHA256"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -20341,59 +21858,62 @@ void JSSHA256Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObje
     ASSERT(inherits(info()));
 }
 
-JSSHA256Constructor::JSSHA256Constructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSSHA256Constructor::JSSHA256Constructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSSHA256Constructor* JSSHA256Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA256Prototype* prototype)
-{
+  }
+
+JSSHA256Constructor* JSSHA256Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA256Prototype* prototype) {
     JSSHA256Constructor* ptr = new (NotNull, JSC::allocateCell<JSSHA256Constructor>(vm)) JSSHA256Constructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSSHA256Constructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSSHA256Constructor();
     Structure* structure = globalObject->JSSHA256Structure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSSHA256Structure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSSHA256Structure()
+      );
     }
 
     void* ptr = SHA256Class__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSSHA256* instance = JSSHA256::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSSHA256Constructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA256Prototype* prototype)
 {
+
 }
 
 const ClassInfo JSSHA256Constructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA256Constructor) };
 
-extern "C" EncodedJSValue SHA256__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue SHA256__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSSHA256Constructor());
-}
+  }
 
 JSSHA256::~JSSHA256()
 {
@@ -20405,7 +21925,7 @@ void JSSHA256::destroy(JSCell* cell)
 {
     static_cast<JSSHA256*>(cell)->JSSHA256::~JSSHA256();
 }
-
+  
 const ClassInfo JSSHA256::s_info = { "SHA256"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA256) };
 
 void JSSHA256::finishCreation(VM& vm)
@@ -20414,38 +21934,37 @@ void JSSHA256::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSSHA256* JSSHA256::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSSHA256* ptr = new (NotNull, JSC::allocateCell<JSSHA256>(vm)) JSSHA256(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* SHA256__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSSHA256* JSSHA256::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSSHA256* ptr = new (NotNull, JSC::allocateCell<JSSHA256>(vm)) JSSHA256(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSSHA256* object = JSC::jsDynamicCast<JSSHA256*>(cell);
+extern "C" void* SHA256__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSSHA256* object = JSC::jsDynamicCast<JSSHA256*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool SHA256__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSSHA256* object = JSC::jsDynamicCast<JSSHA256*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool SHA256__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSSHA256* object = JSC::jsDynamicCast<JSSHA256*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t SHA256__ptrOffset = JSSHA256::offsetOfWrapped();
 
 void JSSHA256::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -20460,7 +21979,7 @@ void JSSHA256::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSSHA256::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSSHA256Constructor::create(vm, globalObject, WebCore::JSSHA256Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA256Prototype*>(prototype));
+  return WebCore::JSSHA256Constructor::create(vm, globalObject, WebCore::JSSHA256Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA256Prototype*>(prototype));
 }
 
 JSObject* JSSHA256::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -20468,107 +21987,120 @@ JSObject* JSSHA256::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSSHA256Prototype::create(vm, globalObject, JSSHA256Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue SHA256__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSSHA256Structure();
-    JSSHA256* instance = JSSHA256::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSSHA384Prototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSSHA384Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSSHA384Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA384Prototype>(vm)) JSSHA384Prototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA384Prototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSSHA384Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue SHA256__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSSHA256Structure();
+  JSSHA256* instance = JSSHA256::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSSHA384Prototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSSHA384Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSSHA384Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA384Prototype>(vm)) JSSHA384Prototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA384Prototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSSHA384Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSSHA384Constructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSSHA384Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA384Prototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
+    public:
+        using Base = JSC::InternalFunction;
+        static JSSHA384Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA384Prototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA384Constructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA384Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA384Constructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA384Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA384Constructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA384Prototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSSHA384Constructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA384Prototype* prototype);
+    };
 
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA384Constructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA384Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA384Constructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA384Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA384Constructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA384Prototype* prototype);
+extern "C" void* SHA384Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsSHA384Constructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSSHA384Constructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA384Prototype* prototype);
-};
 
-extern "C" void* SHA384Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsSHA384Constructor);
 
 extern "C" void SHA384Class__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue SHA384Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SHA384Prototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue SHA384Prototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA384Prototype__digestCallback);
 
+
 extern "C" EncodedJSValue SHA384Prototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA384Prototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA384Prototype, JSSHA384Prototype::Base);
 
-static const HashTableValue JSSHA384PrototypeTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA384Prototype__byteLengthGetterWrap, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA384Prototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA384Prototype__updateCallback, 1 } }
+
+  static const HashTableValue JSSHA384PrototypeTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA384Prototype__byteLengthGetterWrap, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA384Prototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA384Prototype__updateCallback, 1 } }
 };
 
+
+
 const ClassInfo JSSHA384Prototype::s_info = { "SHA384"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA384Prototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsSHA384Constructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -20579,12 +22111,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsSHA384Constructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for SHA384"_s);
     return JSValue::encode(globalObject->JSSHA384Constructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(SHA384Prototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSHA384* thisObject = jsCast<JSSHA384*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -20592,62 +22126,65 @@ JSC_DEFINE_CUSTOM_GETTER(SHA384Prototype__byteLengthGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(SHA384Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SHA384Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSHA384* thisObject = jsDynamicCast<JSSHA384*>(callFrame->thisValue());
+        JSSHA384* thisObject = jsDynamicCast<JSSHA384*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA384"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA384"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA384Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return SHA384Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(SHA384Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(SHA384Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSSHA384* thisObject = jsDynamicCast<JSSHA384*>(callFrame->thisValue());
 
-    JSSHA384* thisObject = jsDynamicCast<JSSHA384*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA384"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA384"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA384Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return SHA384Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSSHA384Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -20659,11 +22196,12 @@ void JSSHA384Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalO
 extern "C" JSC_DECLARE_CUSTOM_GETTER(SHA384Class__getByteLengthStatic);
 extern "C" JSC_DECLARE_HOST_FUNCTION(SHA384Class__hash);
 
-static const HashTableValue JSSHA384ConstructorTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA384Class__getByteLengthStatic, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA384Class__hash, 2 } }
+  static const HashTableValue JSSHA384ConstructorTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA384Class__getByteLengthStatic, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA384Class__hash, 2 } }
 };
 
+
 void JSSHA384Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA384Prototype* prototype)
 {
     Base::finishCreation(vm, 0, "SHA384"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -20672,59 +22210,62 @@ void JSSHA384Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObje
     ASSERT(inherits(info()));
 }
 
-JSSHA384Constructor::JSSHA384Constructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSSHA384Constructor::JSSHA384Constructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSSHA384Constructor* JSSHA384Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA384Prototype* prototype)
-{
+  }
+
+JSSHA384Constructor* JSSHA384Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA384Prototype* prototype) {
     JSSHA384Constructor* ptr = new (NotNull, JSC::allocateCell<JSSHA384Constructor>(vm)) JSSHA384Constructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSSHA384Constructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSSHA384Constructor();
     Structure* structure = globalObject->JSSHA384Structure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSSHA384Structure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSSHA384Structure()
+      );
     }
 
     void* ptr = SHA384Class__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSSHA384* instance = JSSHA384::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSSHA384Constructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA384Prototype* prototype)
 {
+
 }
 
 const ClassInfo JSSHA384Constructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA384Constructor) };
 
-extern "C" EncodedJSValue SHA384__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue SHA384__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSSHA384Constructor());
-}
+  }
 
 JSSHA384::~JSSHA384()
 {
@@ -20736,7 +22277,7 @@ void JSSHA384::destroy(JSCell* cell)
 {
     static_cast<JSSHA384*>(cell)->JSSHA384::~JSSHA384();
 }
-
+  
 const ClassInfo JSSHA384::s_info = { "SHA384"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA384) };
 
 void JSSHA384::finishCreation(VM& vm)
@@ -20745,38 +22286,37 @@ void JSSHA384::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSSHA384* JSSHA384::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSSHA384* ptr = new (NotNull, JSC::allocateCell<JSSHA384>(vm)) JSSHA384(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* SHA384__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSSHA384* JSSHA384::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSSHA384* ptr = new (NotNull, JSC::allocateCell<JSSHA384>(vm)) JSSHA384(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSSHA384* object = JSC::jsDynamicCast<JSSHA384*>(cell);
+extern "C" void* SHA384__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSSHA384* object = JSC::jsDynamicCast<JSSHA384*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool SHA384__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSSHA384* object = JSC::jsDynamicCast<JSSHA384*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool SHA384__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSSHA384* object = JSC::jsDynamicCast<JSSHA384*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t SHA384__ptrOffset = JSSHA384::offsetOfWrapped();
 
 void JSSHA384::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -20791,7 +22331,7 @@ void JSSHA384::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSSHA384::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSSHA384Constructor::create(vm, globalObject, WebCore::JSSHA384Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA384Prototype*>(prototype));
+  return WebCore::JSSHA384Constructor::create(vm, globalObject, WebCore::JSSHA384Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA384Prototype*>(prototype));
 }
 
 JSObject* JSSHA384::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -20799,107 +22339,120 @@ JSObject* JSSHA384::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSSHA384Prototype::create(vm, globalObject, JSSHA384Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue SHA384__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSSHA384Structure();
-    JSSHA384* instance = JSSHA384::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSSHA512Prototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSSHA512Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSSHA512Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA512Prototype>(vm)) JSSHA512Prototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA512Prototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSSHA512Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue SHA384__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSSHA384Structure();
+  JSSHA384* instance = JSSHA384::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSSHA512Prototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSSHA512Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSSHA512Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA512Prototype>(vm)) JSSHA512Prototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA512Prototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSSHA512Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSSHA512Constructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSSHA512Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA512Prototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
+    public:
+        using Base = JSC::InternalFunction;
+        static JSSHA512Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA512Prototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA512Constructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA512Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512Constructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA512Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512Constructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA512Prototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSSHA512Constructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA512Prototype* prototype);
+    };
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA512Constructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA512Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512Constructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA512Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512Constructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA512Prototype* prototype);
+extern "C" void* SHA512Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsSHA512Constructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSSHA512Constructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA512Prototype* prototype);
-};
 
-extern "C" void* SHA512Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsSHA512Constructor);
 
 extern "C" void SHA512Class__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue SHA512Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SHA512Prototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue SHA512Prototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA512Prototype__digestCallback);
 
+
 extern "C" EncodedJSValue SHA512Prototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA512Prototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA512Prototype, JSSHA512Prototype::Base);
 
-static const HashTableValue JSSHA512PrototypeTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA512Prototype__byteLengthGetterWrap, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512Prototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512Prototype__updateCallback, 1 } }
+
+  static const HashTableValue JSSHA512PrototypeTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA512Prototype__byteLengthGetterWrap, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512Prototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512Prototype__updateCallback, 1 } }
 };
 
+
+
 const ClassInfo JSSHA512Prototype::s_info = { "SHA512"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA512Prototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsSHA512Constructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -20910,12 +22463,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsSHA512Constructor, (JSGlobalObject * lexicalGlobalObj
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for SHA512"_s);
     return JSValue::encode(globalObject->JSSHA512Constructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(SHA512Prototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSHA512* thisObject = jsCast<JSSHA512*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -20923,62 +22478,65 @@ JSC_DEFINE_CUSTOM_GETTER(SHA512Prototype__byteLengthGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(SHA512Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SHA512Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSHA512* thisObject = jsDynamicCast<JSSHA512*>(callFrame->thisValue());
+        JSSHA512* thisObject = jsDynamicCast<JSSHA512*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA512"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA512"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA512Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return SHA512Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(SHA512Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(SHA512Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSSHA512* thisObject = jsDynamicCast<JSSHA512*>(callFrame->thisValue());
 
-    JSSHA512* thisObject = jsDynamicCast<JSSHA512*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA512"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA512"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA512Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return SHA512Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSSHA512Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -20990,11 +22548,12 @@ void JSSHA512Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalO
 extern "C" JSC_DECLARE_CUSTOM_GETTER(SHA512Class__getByteLengthStatic);
 extern "C" JSC_DECLARE_HOST_FUNCTION(SHA512Class__hash);
 
-static const HashTableValue JSSHA512ConstructorTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA512Class__getByteLengthStatic, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512Class__hash, 2 } }
+  static const HashTableValue JSSHA512ConstructorTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA512Class__getByteLengthStatic, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512Class__hash, 2 } }
 };
 
+
 void JSSHA512Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA512Prototype* prototype)
 {
     Base::finishCreation(vm, 0, "SHA512"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -21003,59 +22562,62 @@ void JSSHA512Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObje
     ASSERT(inherits(info()));
 }
 
-JSSHA512Constructor::JSSHA512Constructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSSHA512Constructor::JSSHA512Constructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSSHA512Constructor* JSSHA512Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA512Prototype* prototype)
-{
+  }
+
+JSSHA512Constructor* JSSHA512Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA512Prototype* prototype) {
     JSSHA512Constructor* ptr = new (NotNull, JSC::allocateCell<JSSHA512Constructor>(vm)) JSSHA512Constructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSSHA512Constructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSSHA512Constructor();
     Structure* structure = globalObject->JSSHA512Structure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSSHA512Structure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSSHA512Structure()
+      );
     }
 
     void* ptr = SHA512Class__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSSHA512* instance = JSSHA512::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSSHA512Constructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA512Prototype* prototype)
 {
+
 }
 
 const ClassInfo JSSHA512Constructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA512Constructor) };
 
-extern "C" EncodedJSValue SHA512__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue SHA512__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSSHA512Constructor());
-}
+  }
 
 JSSHA512::~JSSHA512()
 {
@@ -21067,7 +22629,7 @@ void JSSHA512::destroy(JSCell* cell)
 {
     static_cast<JSSHA512*>(cell)->JSSHA512::~JSSHA512();
 }
-
+  
 const ClassInfo JSSHA512::s_info = { "SHA512"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA512) };
 
 void JSSHA512::finishCreation(VM& vm)
@@ -21076,38 +22638,37 @@ void JSSHA512::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSSHA512* JSSHA512::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSSHA512* ptr = new (NotNull, JSC::allocateCell<JSSHA512>(vm)) JSSHA512(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* SHA512__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSSHA512* JSSHA512::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSSHA512* ptr = new (NotNull, JSC::allocateCell<JSSHA512>(vm)) JSSHA512(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSSHA512* object = JSC::jsDynamicCast<JSSHA512*>(cell);
+extern "C" void* SHA512__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSSHA512* object = JSC::jsDynamicCast<JSSHA512*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool SHA512__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSSHA512* object = JSC::jsDynamicCast<JSSHA512*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool SHA512__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSSHA512* object = JSC::jsDynamicCast<JSSHA512*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t SHA512__ptrOffset = JSSHA512::offsetOfWrapped();
 
 void JSSHA512::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -21122,7 +22683,7 @@ void JSSHA512::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSSHA512::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSSHA512Constructor::create(vm, globalObject, WebCore::JSSHA512Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA512Prototype*>(prototype));
+  return WebCore::JSSHA512Constructor::create(vm, globalObject, WebCore::JSSHA512Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA512Prototype*>(prototype));
 }
 
 JSObject* JSSHA512::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -21130,107 +22691,120 @@ JSObject* JSSHA512::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSSHA512Prototype::create(vm, globalObject, JSSHA512Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue SHA512__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSSHA512Structure();
-    JSSHA512* instance = JSSHA512::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSSHA512_256Prototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSSHA512_256Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSSHA512_256Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA512_256Prototype>(vm)) JSSHA512_256Prototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA512_256Prototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSSHA512_256Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue SHA512__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSSHA512Structure();
+  JSSHA512* instance = JSSHA512::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSSHA512_256Prototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSSHA512_256Prototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSSHA512_256Prototype* ptr = new (NotNull, JSC::allocateCell<JSSHA512_256Prototype>(vm)) JSSHA512_256Prototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA512_256Prototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSSHA512_256Prototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSSHA512_256Constructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSSHA512_256Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA512_256Prototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
+    public:
+        using Base = JSC::InternalFunction;
+        static JSSHA512_256Constructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA512_256Prototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA512_256Constructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA512_256Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512_256Constructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA512_256Constructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512_256Constructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA512_256Prototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSSHA512_256Constructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA512_256Prototype* prototype);
+    };
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA512_256Constructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA512_256Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512_256Constructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA512_256Constructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512_256Constructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSSHA512_256Prototype* prototype);
+extern "C" void* SHA512_256Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsSHA512_256Constructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSSHA512_256Constructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSSHA512_256Prototype* prototype);
-};
 
-extern "C" void* SHA512_256Class__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsSHA512_256Constructor);
 
 extern "C" void SHA512_256Class__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue SHA512_256Prototype__getByteLength(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SHA512_256Prototype__byteLengthGetterWrap);
 
+
 extern "C" EncodedJSValue SHA512_256Prototype__digest(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA512_256Prototype__digestCallback);
 
+
 extern "C" EncodedJSValue SHA512_256Prototype__update(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SHA512_256Prototype__updateCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSHA512_256Prototype, JSSHA512_256Prototype::Base);
 
-static const HashTableValue JSSHA512_256PrototypeTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA512_256Prototype__byteLengthGetterWrap, 0 } },
-    { "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512_256Prototype__digestCallback, 0 } },
-    { "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512_256Prototype__updateCallback, 1 } }
+
+  static const HashTableValue JSSHA512_256PrototypeTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA512_256Prototype__byteLengthGetterWrap, 0 } }  ,
+{ "digest"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512_256Prototype__digestCallback, 0 } }  ,
+{ "update"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512_256Prototype__updateCallback, 1 } }
 };
 
+
+
 const ClassInfo JSSHA512_256Prototype::s_info = { "SHA512_256"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA512_256Prototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsSHA512_256Constructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -21241,12 +22815,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsSHA512_256Constructor, (JSGlobalObject * lexicalGloba
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for SHA512_256"_s);
     return JSValue::encode(globalObject->JSSHA512_256Constructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(SHA512_256Prototype__byteLengthGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSHA512_256* thisObject = jsCast<JSSHA512_256*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -21254,62 +22830,65 @@ JSC_DEFINE_CUSTOM_GETTER(SHA512_256Prototype__byteLengthGetterWrap, (JSGlobalObj
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(SHA512_256Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SHA512_256Prototype__digestCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSHA512_256* thisObject = jsDynamicCast<JSSHA512_256*>(callFrame->thisValue());
+        JSSHA512_256* thisObject = jsDynamicCast<JSSHA512_256*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA512_256"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA512_256"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA512_256Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return SHA512_256Prototype__digest(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(SHA512_256Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(SHA512_256Prototype__updateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSSHA512_256* thisObject = jsDynamicCast<JSSHA512_256*>(callFrame->thisValue());
 
-    JSSHA512_256* thisObject = jsDynamicCast<JSSHA512_256*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA512_256"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof SHA512_256"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SHA512_256Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return SHA512_256Prototype__update(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSSHA512_256Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -21321,11 +22900,12 @@ void JSSHA512_256Prototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* glo
 extern "C" JSC_DECLARE_CUSTOM_GETTER(SHA512_256Class__getByteLengthStatic);
 extern "C" JSC_DECLARE_HOST_FUNCTION(SHA512_256Class__hash);
 
-static const HashTableValue JSSHA512_256ConstructorTableValues[] = {
-    { "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA512_256Class__getByteLengthStatic, 0 } },
-    { "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512_256Class__hash, 2 } }
+  static const HashTableValue JSSHA512_256ConstructorTableValues[] = {
+{ "byteLength"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SHA512_256Class__getByteLengthStatic, 0 } }  ,
+{ "hash"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SHA512_256Class__hash, 2 } }
 };
 
+
 void JSSHA512_256Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA512_256Prototype* prototype)
 {
     Base::finishCreation(vm, 0, "SHA512_256"_s, PropertyAdditionMode::WithoutStructureTransition);
@@ -21334,59 +22914,62 @@ void JSSHA512_256Constructor::finishCreation(VM& vm, JSC::JSGlobalObject* global
     ASSERT(inherits(info()));
 }
 
-JSSHA512_256Constructor::JSSHA512_256Constructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSSHA512_256Constructor::JSSHA512_256Constructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSSHA512_256Constructor* JSSHA512_256Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA512_256Prototype* prototype)
-{
+  }
+
+JSSHA512_256Constructor* JSSHA512_256Constructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSSHA512_256Prototype* prototype) {
     JSSHA512_256Constructor* ptr = new (NotNull, JSC::allocateCell<JSSHA512_256Constructor>(vm)) JSSHA512_256Constructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSSHA512_256Constructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSSHA512_256Constructor();
     Structure* structure = globalObject->JSSHA512_256Structure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSSHA512_256Structure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSSHA512_256Structure()
+      );
     }
 
     void* ptr = SHA512_256Class__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSSHA512_256* instance = JSSHA512_256::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSSHA512_256Constructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSSHA512_256Prototype* prototype)
 {
+
 }
 
 const ClassInfo JSSHA512_256Constructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA512_256Constructor) };
 
-extern "C" EncodedJSValue SHA512_256__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue SHA512_256__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSSHA512_256Constructor());
-}
+  }
 
 JSSHA512_256::~JSSHA512_256()
 {
@@ -21398,7 +22981,7 @@ void JSSHA512_256::destroy(JSCell* cell)
 {
     static_cast<JSSHA512_256*>(cell)->JSSHA512_256::~JSSHA512_256();
 }
-
+  
 const ClassInfo JSSHA512_256::s_info = { "SHA512_256"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSHA512_256) };
 
 void JSSHA512_256::finishCreation(VM& vm)
@@ -21407,38 +22990,37 @@ void JSSHA512_256::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSSHA512_256* JSSHA512_256::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSSHA512_256* ptr = new (NotNull, JSC::allocateCell<JSSHA512_256>(vm)) JSSHA512_256(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* SHA512_256__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSSHA512_256* JSSHA512_256::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSSHA512_256* ptr = new (NotNull, JSC::allocateCell<JSSHA512_256>(vm)) JSSHA512_256(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSSHA512_256* object = JSC::jsDynamicCast<JSSHA512_256*>(cell);
+extern "C" void* SHA512_256__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSSHA512_256* object = JSC::jsDynamicCast<JSSHA512_256*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool SHA512_256__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSSHA512_256* object = JSC::jsDynamicCast<JSSHA512_256*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool SHA512_256__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSSHA512_256* object = JSC::jsDynamicCast<JSSHA512_256*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t SHA512_256__ptrOffset = JSSHA512_256::offsetOfWrapped();
 
 void JSSHA512_256::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -21453,7 +23035,7 @@ void JSSHA512_256::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSSHA512_256::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSSHA512_256Constructor::create(vm, globalObject, WebCore::JSSHA512_256Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA512_256Prototype*>(prototype));
+  return WebCore::JSSHA512_256Constructor::create(vm, globalObject, WebCore::JSSHA512_256Constructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSSHA512_256Prototype*>(prototype));
 }
 
 JSObject* JSSHA512_256::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -21461,131 +23043,148 @@ JSObject* JSSHA512_256::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSSHA512_256Prototype::create(vm, globalObject, JSSHA512_256Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue SHA512_256__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSSHA512_256Structure();
-    JSSHA512_256* instance = JSSHA512_256::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-class JSServerWebSocketPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSServerWebSocketPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSServerWebSocketPrototype* ptr = new (NotNull, JSC::allocateCell<JSServerWebSocketPrototype>(vm)) JSServerWebSocketPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSServerWebSocketPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSServerWebSocketPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+extern "C" EncodedJSValue SHA512_256__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSSHA512_256Structure();
+  JSSHA512_256* instance = JSSHA512_256::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+  class JSServerWebSocketPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSServerWebSocketPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSServerWebSocketPrototype* ptr = new (NotNull, JSC::allocateCell<JSServerWebSocketPrototype>(vm)) JSServerWebSocketPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSServerWebSocketPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSServerWebSocketPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSServerWebSocketConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSServerWebSocketConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSServerWebSocketPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSServerWebSocketConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSServerWebSocketPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSServerWebSocketConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForServerWebSocketConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForServerWebSocketConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForServerWebSocketConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForServerWebSocketConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSServerWebSocketPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSServerWebSocketConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSServerWebSocketPrototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSServerWebSocketConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForServerWebSocketConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForServerWebSocketConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForServerWebSocketConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForServerWebSocketConstructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSServerWebSocketPrototype* prototype);
+extern "C" void* ServerWebSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsServerWebSocketConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSServerWebSocketConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSServerWebSocketPrototype* prototype);
-};
 
-extern "C" void* ServerWebSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsServerWebSocketConstructor);
 
 extern "C" void ServerWebSocketClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue ServerWebSocketPrototype__getBinaryType(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ServerWebSocketPrototype__binaryTypeGetterWrap);
 
+
 extern "C" bool ServerWebSocketPrototype__setBinaryType(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
 JSC_DECLARE_CUSTOM_SETTER(ServerWebSocketPrototype__binaryTypeSetterWrap);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__close(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__closeCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__cork(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__corkCallback);
 
+
 extern "C" JSC::EncodedJSValue ServerWebSocketPrototype__getData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ServerWebSocketPrototype__dataGetterWrap);
 
+
 extern "C" bool ServerWebSocketPrototype__setData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
 JSC_DECLARE_CUSTOM_SETTER(ServerWebSocketPrototype__dataSetterWrap);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__getBufferedAmount(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__getBufferedAmountCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__isSubscribed(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__isSubscribedCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__ping(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__pingCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__pong(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__pongCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__publish(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__publishCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__publishBinary(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__publishBinaryCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(ServerWebSocketPrototype__publishBinaryWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSString* arg0, JSC::JSUint8Array* arg1));
-extern "C" EncodedJSValue ServerWebSocketPrototype__publishBinaryWithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSString* arg0, JSC::JSUint8Array* arg1);
+  extern "C" EncodedJSValue ServerWebSocketPrototype__publishBinaryWithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject, JSC::JSString* arg0, JSC::JSUint8Array* arg1);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForServerWebSocketPrototype__publishBinary(ServerWebSocketPrototype__publishBinaryWithoutTypeChecksWrapper,
-    JSServerWebSocket::info(),
-    JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()),
-    JSC::SpecHeapTop, JSC::SpecString, JSC::SpecUint8Array);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForServerWebSocketPrototype__publishBinary(ServerWebSocketPrototype__publishBinaryWithoutTypeChecksWrapper, 
+  JSServerWebSocket::info(), 
+  JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), 
+  JSC::SpecHeapTop, JSC::SpecString, JSC::SpecUint8Array);
 
 JSC_DEFINE_JIT_OPERATION(ServerWebSocketPrototype__publishBinaryWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSString* arg0, JSC::JSUint8Array* arg1))
 {
@@ -21600,13 +23199,14 @@ JSC_DEFINE_JIT_OPERATION(ServerWebSocketPrototype__publishBinaryWithoutTypeCheck
 extern "C" EncodedJSValue ServerWebSocketPrototype__publishText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__publishTextCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(ServerWebSocketPrototype__publishTextWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSString* arg0, JSC::JSString* arg1));
-extern "C" EncodedJSValue ServerWebSocketPrototype__publishTextWithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSString* arg0, JSC::JSString* arg1);
+  extern "C" EncodedJSValue ServerWebSocketPrototype__publishTextWithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject, JSC::JSString* arg0, JSC::JSString* arg1);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForServerWebSocketPrototype__publishText(ServerWebSocketPrototype__publishTextWithoutTypeChecksWrapper,
-    JSServerWebSocket::info(),
-    JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()),
-    JSC::SpecHeapTop, JSC::SpecString, JSC::SpecString);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForServerWebSocketPrototype__publishText(ServerWebSocketPrototype__publishTextWithoutTypeChecksWrapper, 
+  JSServerWebSocket::info(), 
+  JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), 
+  JSC::SpecHeapTop, JSC::SpecString, JSC::SpecString);
 
 JSC_DEFINE_JIT_OPERATION(ServerWebSocketPrototype__publishTextWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSString* arg0, JSC::JSString* arg1))
 {
@@ -21621,22 +23221,26 @@ JSC_DEFINE_JIT_OPERATION(ServerWebSocketPrototype__publishTextWithoutTypeChecksW
 extern "C" JSC::EncodedJSValue ServerWebSocketPrototype__getReadyState(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ServerWebSocketPrototype__readyStateGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue ServerWebSocketPrototype__getRemoteAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(ServerWebSocketPrototype__remoteAddressGetterWrap);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__send(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__sendCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__sendBinary(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__sendBinaryCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(ServerWebSocketPrototype__sendBinaryWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSUint8Array* arg0, bool arg1));
-extern "C" EncodedJSValue ServerWebSocketPrototype__sendBinaryWithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSUint8Array* arg0, bool arg1);
+  extern "C" EncodedJSValue ServerWebSocketPrototype__sendBinaryWithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject, JSC::JSUint8Array* arg0, bool arg1);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForServerWebSocketPrototype__sendBinary(ServerWebSocketPrototype__sendBinaryWithoutTypeChecksWrapper,
-    JSServerWebSocket::info(),
-    JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()),
-    JSC::SpecHeapTop, JSC::SpecUint8Array, JSC::SpecBoolean);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForServerWebSocketPrototype__sendBinary(ServerWebSocketPrototype__sendBinaryWithoutTypeChecksWrapper, 
+  JSServerWebSocket::info(), 
+  JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), 
+  JSC::SpecHeapTop, JSC::SpecUint8Array, JSC::SpecBoolean);
 
 JSC_DEFINE_JIT_OPERATION(ServerWebSocketPrototype__sendBinaryWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSUint8Array* arg0, bool arg1))
 {
@@ -21651,13 +23255,14 @@ JSC_DEFINE_JIT_OPERATION(ServerWebSocketPrototype__sendBinaryWithoutTypeChecksWr
 extern "C" EncodedJSValue ServerWebSocketPrototype__sendText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__sendTextCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(ServerWebSocketPrototype__sendTextWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSString* arg0, bool arg1));
-extern "C" EncodedJSValue ServerWebSocketPrototype__sendTextWithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSString* arg0, bool arg1);
+  extern "C" EncodedJSValue ServerWebSocketPrototype__sendTextWithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject, JSC::JSString* arg0, bool arg1);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForServerWebSocketPrototype__sendText(ServerWebSocketPrototype__sendTextWithoutTypeChecksWrapper,
-    JSServerWebSocket::info(),
-    JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()),
-    JSC::SpecHeapTop, JSC::SpecString, JSC::SpecBoolean);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForServerWebSocketPrototype__sendText(ServerWebSocketPrototype__sendTextWithoutTypeChecksWrapper, 
+  JSServerWebSocket::info(), 
+  JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), 
+  JSC::SpecHeapTop, JSC::SpecString, JSC::SpecBoolean);
 
 JSC_DEFINE_JIT_OPERATION(ServerWebSocketPrototype__sendTextWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSString* arg0, bool arg1))
 {
@@ -21672,38 +23277,46 @@ JSC_DEFINE_JIT_OPERATION(ServerWebSocketPrototype__sendTextWithoutTypeChecksWrap
 extern "C" EncodedJSValue ServerWebSocketPrototype__subscribe(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__subscribeCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__terminate(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__terminateCallback);
 
+
 extern "C" EncodedJSValue ServerWebSocketPrototype__unsubscribe(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(ServerWebSocketPrototype__unsubscribeCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSServerWebSocketPrototype, JSServerWebSocketPrototype::Base);
 
-static const HashTableValue JSServerWebSocketPrototypeTableValues[] = {
-    { "binaryType"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__binaryTypeGetterWrap, ServerWebSocketPrototype__binaryTypeSetterWrap } },
-    { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__closeCallback, 3 } },
-    { "cork"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__corkCallback, 1 } },
-    { "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__dataGetterWrap, ServerWebSocketPrototype__dataSetterWrap } },
-    { "getBufferedAmount"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__getBufferedAmountCallback, 0 } },
-    { "isSubscribed"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__isSubscribedCallback, 1 } },
-    { "ping"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__pingCallback, 1 } },
-    { "pong"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__pongCallback, 1 } },
-    { "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__publishCallback, 3 } },
-    { "publishBinary"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, ServerWebSocketPrototype__publishBinaryCallback, &DOMJITSignatureForServerWebSocketPrototype__publishBinary } },
-    { "publishText"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, ServerWebSocketPrototype__publishTextCallback, &DOMJITSignatureForServerWebSocketPrototype__publishText } },
-    { "readyState"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__readyStateGetterWrap, 0 } },
-    { "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__remoteAddressGetterWrap, 0 } },
-    { "send"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__sendCallback, 2 } },
-    { "sendBinary"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, ServerWebSocketPrototype__sendBinaryCallback, &DOMJITSignatureForServerWebSocketPrototype__sendBinary } },
-    { "sendText"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, ServerWebSocketPrototype__sendTextCallback, &DOMJITSignatureForServerWebSocketPrototype__sendText } },
-    { "subscribe"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__subscribeCallback, 1 } },
-    { "terminate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__terminateCallback, 0 } },
-    { "unsubscribe"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__unsubscribeCallback, 1 } }
+
+  static const HashTableValue JSServerWebSocketPrototypeTableValues[] = {
+{ "binaryType"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__binaryTypeGetterWrap, ServerWebSocketPrototype__binaryTypeSetterWrap } }  ,
+{ "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__closeCallback, 3 } }  ,
+{ "cork"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__corkCallback, 1 } }  ,
+{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__dataGetterWrap, ServerWebSocketPrototype__dataSetterWrap } }  ,
+{ "getBufferedAmount"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__getBufferedAmountCallback, 0 } }  ,
+{ "isSubscribed"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__isSubscribedCallback, 1 } }  ,
+{ "ping"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__pingCallback, 1 } }  ,
+{ "pong"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__pongCallback, 1 } }  ,
+{ "publish"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__publishCallback, 3 } }  ,
+{ "publishBinary"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, ServerWebSocketPrototype__publishBinaryCallback, &DOMJITSignatureForServerWebSocketPrototype__publishBinary } }  ,
+{ "publishText"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, ServerWebSocketPrototype__publishTextCallback, &DOMJITSignatureForServerWebSocketPrototype__publishText } }  ,
+{ "readyState"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__readyStateGetterWrap, 0 } }  ,
+{ "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, ServerWebSocketPrototype__remoteAddressGetterWrap, 0 } }  ,
+{ "send"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__sendCallback, 2 } }  ,
+{ "sendBinary"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, ServerWebSocketPrototype__sendBinaryCallback, &DOMJITSignatureForServerWebSocketPrototype__sendBinary } }  ,
+{ "sendText"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, ServerWebSocketPrototype__sendTextCallback, &DOMJITSignatureForServerWebSocketPrototype__sendText } }  ,
+{ "subscribe"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__subscribeCallback, 1 } }  ,
+{ "terminate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__terminateCallback, 0 } }  ,
+{ "unsubscribe"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, ServerWebSocketPrototype__unsubscribeCallback, 1 } }
 };
 
+
+
 const ClassInfo JSServerWebSocketPrototype::s_info = { "ServerWebSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSServerWebSocketPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsServerWebSocketConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -21714,12 +23327,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsServerWebSocketConstructor, (JSGlobalObject * lexical
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for ServerWebSocket"_s);
     return JSValue::encode(globalObject->JSServerWebSocketConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(ServerWebSocketPrototype__binaryTypeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSServerWebSocket* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -21727,6 +23342,7 @@ JSC_DEFINE_CUSTOM_GETTER(ServerWebSocketPrototype__binaryTypeGetterWrap, (JSGlob
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_SETTER(ServerWebSocketPrototype__binaryTypeSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
 {
@@ -21739,92 +23355,99 @@ JSC_DEFINE_CUSTOM_SETTER(ServerWebSocketPrototype__binaryTypeSetterWrap, (JSGlob
     RELEASE_AND_RETURN(throwScope, result);
 }
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__close(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__close(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__corkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__corkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__cork(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ServerWebSocketPrototype__cork(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ServerWebSocketPrototype__dataGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSServerWebSocket* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_data.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ServerWebSocketPrototype__getData(thisObject->wrapped(), globalObject));
+        ServerWebSocketPrototype__getData(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_data.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ServerWebSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
-    thisObject->m_data.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ServerWebSocketPrototype__dataGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ServerWebSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
+      thisObject->m_data.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ServerWebSocketPrototype__dataGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_data.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_SETTER(ServerWebSocketPrototype__dataSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
 {
@@ -21837,206 +23460,214 @@ JSC_DEFINE_CUSTOM_SETTER(ServerWebSocketPrototype__dataSetterWrap, (JSGlobalObje
     RELEASE_AND_RETURN(throwScope, result);
 }
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__getBufferedAmountCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__getBufferedAmountCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__getBufferedAmount(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__getBufferedAmount(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__isSubscribedCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__isSubscribedCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__isSubscribed(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__isSubscribed(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__pingCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__pingCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__ping(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__ping(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__pongCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__pongCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__pong(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__pong(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__publishCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__publish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__publish(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__publishBinaryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__publishBinaryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__publishBinary(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__publishBinary(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__publishTextCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__publishTextCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__publishText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ServerWebSocketPrototype__publishText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(ServerWebSocketPrototype__readyStateGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSServerWebSocket* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -22044,205 +23675,216 @@ JSC_DEFINE_CUSTOM_GETTER(ServerWebSocketPrototype__readyStateGetterWrap, (JSGlob
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(ServerWebSocketPrototype__remoteAddressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSServerWebSocket* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_remoteAddress.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        ServerWebSocketPrototype__getRemoteAddress(thisObject->wrapped(), globalObject));
+        ServerWebSocketPrototype__getRemoteAddress(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_remoteAddress.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void ServerWebSocketPrototype__remoteAddressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
-    thisObject->m_remoteAddress.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue ServerWebSocketPrototype__remoteAddressGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void ServerWebSocketPrototype__remoteAddressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
+      thisObject->m_remoteAddress.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue ServerWebSocketPrototype__remoteAddressGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSServerWebSocket*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_remoteAddress.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__sendCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__sendCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__send(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__send(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__sendBinaryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__sendBinaryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__sendBinary(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__sendBinary(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__sendTextCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__sendTextCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__sendText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__sendText(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__subscribeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__subscribeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__subscribe(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__subscribe(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__terminateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__terminateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__terminate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return ServerWebSocketPrototype__terminate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__unsubscribeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(ServerWebSocketPrototype__unsubscribeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
 
-    JSServerWebSocket* thisObject = jsDynamicCast<JSServerWebSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof ServerWebSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return ServerWebSocketPrototype__unsubscribe(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return ServerWebSocketPrototype__unsubscribe(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSServerWebSocketPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -22254,64 +23896,67 @@ void JSServerWebSocketPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject
 void JSServerWebSocketConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSServerWebSocketPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "ServerWebSocket"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSServerWebSocketConstructor::JSServerWebSocketConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSServerWebSocketConstructor::JSServerWebSocketConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSServerWebSocketConstructor* JSServerWebSocketConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSServerWebSocketPrototype* prototype)
-{
+  }
+
+JSServerWebSocketConstructor* JSServerWebSocketConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSServerWebSocketPrototype* prototype) {
     JSServerWebSocketConstructor* ptr = new (NotNull, JSC::allocateCell<JSServerWebSocketConstructor>(vm)) JSServerWebSocketConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSServerWebSocketConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSServerWebSocketConstructor();
     Structure* structure = globalObject->JSServerWebSocketStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSServerWebSocketStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSServerWebSocketStructure()
+      );
     }
 
     void* ptr = ServerWebSocketClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSServerWebSocket* instance = JSServerWebSocket::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSServerWebSocketConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSServerWebSocketPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSServerWebSocketConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSServerWebSocketConstructor) };
 
-extern "C" EncodedJSValue ServerWebSocket__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue ServerWebSocket__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSServerWebSocketConstructor());
-}
+  }
 
 JSServerWebSocket::~JSServerWebSocket()
 {
@@ -22323,7 +23968,7 @@ void JSServerWebSocket::destroy(JSCell* cell)
 {
     static_cast<JSServerWebSocket*>(cell)->JSServerWebSocket::~JSServerWebSocket();
 }
-
+  
 const ClassInfo JSServerWebSocket::s_info = { "ServerWebSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSServerWebSocket) };
 
 void JSServerWebSocket::finishCreation(VM& vm)
@@ -22332,38 +23977,37 @@ void JSServerWebSocket::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSServerWebSocket* JSServerWebSocket::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSServerWebSocket* ptr = new (NotNull, JSC::allocateCell<JSServerWebSocket>(vm)) JSServerWebSocket(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* ServerWebSocket__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSServerWebSocket* JSServerWebSocket::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSServerWebSocket* ptr = new (NotNull, JSC::allocateCell<JSServerWebSocket>(vm)) JSServerWebSocket(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSServerWebSocket* object = JSC::jsDynamicCast<JSServerWebSocket*>(cell);
+extern "C" void* ServerWebSocket__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSServerWebSocket* object = JSC::jsDynamicCast<JSServerWebSocket*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool ServerWebSocket__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSServerWebSocket* object = JSC::jsDynamicCast<JSServerWebSocket*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool ServerWebSocket__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSServerWebSocket* object = JSC::jsDynamicCast<JSServerWebSocket*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t ServerWebSocket__ptrOffset = JSServerWebSocket::offsetOfWrapped();
 
 void JSServerWebSocket::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -22378,7 +24022,7 @@ void JSServerWebSocket::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSServerWebSocket::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSServerWebSocketConstructor::create(vm, globalObject, WebCore::JSServerWebSocketConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSServerWebSocketPrototype*>(prototype));
+  return WebCore::JSServerWebSocketConstructor::create(vm, globalObject, WebCore::JSServerWebSocketConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSServerWebSocketPrototype*>(prototype));
 }
 
 JSObject* JSServerWebSocket::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -22386,13 +24030,12 @@ JSObject* JSServerWebSocket::createPrototype(VM& vm, JSDOMGlobalObject* globalOb
     return JSServerWebSocketPrototype::create(vm, globalObject, JSServerWebSocketPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue ServerWebSocket__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSServerWebSocketStructure();
-    JSServerWebSocket* instance = JSServerWebSocket::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue ServerWebSocket__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSServerWebSocketStructure();
+  JSServerWebSocket* instance = JSServerWebSocket::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -22401,7 +24044,7 @@ void JSServerWebSocket::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSServerWebSocket* thisObject = jsCast<JSServerWebSocket*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -22410,17 +24053,18 @@ DEFINE_VISIT_CHILDREN(JSServerWebSocket);
 template<typename Visitor>
 void JSServerWebSocket::visitAdditionalChildren(Visitor& visitor)
 {
-    JSServerWebSocket* thisObject = this;
+  JSServerWebSocket* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_data);
+    
+        visitor.append(thisObject->m_data);
     visitor.append(thisObject->m_remoteAddress);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSServerWebSocket);
 
 template<typename Visitor>
-void JSServerWebSocket::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSServerWebSocket::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSServerWebSocket* thisObject = jsCast<JSServerWebSocket*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -22428,155 +24072,169 @@ void JSServerWebSocket::visitOutputConstraintsImpl(JSCell* cell, Visitor& visito
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSServerWebSocket);
-class JSStatWatcherPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSStatWatcherPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSStatWatcherPrototype* ptr = new (NotNull, JSC::allocateCell<JSStatWatcherPrototype>(vm)) JSStatWatcherPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSStatWatcherPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSStatWatcherPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSStatWatcherPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSStatWatcherPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSStatWatcherPrototype* ptr = new (NotNull, JSC::allocateCell<JSStatWatcherPrototype>(vm)) JSStatWatcherPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSStatWatcherPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSStatWatcherPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 extern "C" void StatWatcherClass__finalize(void*);
 
+
 extern "C" EncodedJSValue StatWatcherPrototype__doClose(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatWatcherPrototype__closeCallback);
 
+
 extern "C" EncodedJSValue StatWatcherPrototype__doRef(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatWatcherPrototype__refCallback);
 
+
 extern "C" EncodedJSValue StatWatcherPrototype__doUnref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatWatcherPrototype__unrefCallback);
 
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSStatWatcherPrototype, JSStatWatcherPrototype::Base);
 
-static const HashTableValue JSStatWatcherPrototypeTableValues[] = {
-    { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, StatWatcherPrototype__closeCallback, 0 } },
-    { "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, StatWatcherPrototype__refCallback, 0 } },
-    { "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, StatWatcherPrototype__unrefCallback, 0 } }
-};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSStatWatcherPrototype, JSStatWatcherPrototype::Base);
 
-const ClassInfo JSStatWatcherPrototype::s_info = { "StatWatcher"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSStatWatcherPrototype) };
 
-JSC_DEFINE_HOST_FUNCTION(StatWatcherPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+  static const HashTableValue JSStatWatcherPrototypeTableValues[] = {
+{ "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, StatWatcherPrototype__closeCallback, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, StatWatcherPrototype__refCallback, 0 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, StatWatcherPrototype__unrefCallback, 0 } }
+};
 
-    JSStatWatcher* thisObject = jsDynamicCast<JSStatWatcher*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof StatWatcher"_s);
-        return JSValue::encode({});
-    }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+const ClassInfo JSStatWatcherPrototype::s_info = { "StatWatcher"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSStatWatcherPrototype) };
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
 
-    return StatWatcherPrototype__doClose(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(StatWatcherPrototype__closeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(StatWatcherPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSStatWatcher* thisObject = jsDynamicCast<JSStatWatcher*>(callFrame->thisValue());
 
-    JSStatWatcher* thisObject = jsDynamicCast<JSStatWatcher*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof StatWatcher"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof StatWatcher"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatWatcherPrototype__doClose(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return StatWatcherPrototype__doRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(StatWatcherPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(StatWatcherPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSStatWatcher* thisObject = jsDynamicCast<JSStatWatcher*>(callFrame->thisValue());
 
-    JSStatWatcher* thisObject = jsDynamicCast<JSStatWatcher*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof StatWatcher"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof StatWatcher"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatWatcherPrototype__doRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return StatWatcherPrototype__doUnref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
-
-extern "C" void StatWatcherPrototype__listenerSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSStatWatcher*>(JSValue::decode(thisValue));
-    thisObject->m_listener.set(vm, thisObject, JSValue::decode(value));
-}
+    
 
-extern "C" EncodedJSValue StatWatcherPrototype__listenerGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+    JSC_DEFINE_HOST_FUNCTION(StatWatcherPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSStatWatcher* thisObject = jsDynamicCast<JSStatWatcher*>(callFrame->thisValue());
+
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof StatWatcher"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return StatWatcherPrototype__doUnref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
+
+
+  extern "C" void StatWatcherPrototype__listenerSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSStatWatcher*>(JSValue::decode(thisValue));
+      thisObject->m_listener.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue StatWatcherPrototype__listenerGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSStatWatcher*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_listener.get());
-}
+  }
+  
+  
 
 void JSStatWatcherPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -22586,10 +24244,9 @@ void JSStatWatcherPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* gl
 }
 
 extern "C" bool StatWatcher__hasPendingActivity(void* ptr);
-bool JSStatWatcher::hasPendingActivity(void* ctx)
-{
-    return StatWatcher__hasPendingActivity(ctx);
-}
+    bool JSStatWatcher::hasPendingActivity(void* ctx) {
+        return StatWatcher__hasPendingActivity(ctx);
+    }
 
 JSStatWatcher::~JSStatWatcher()
 {
@@ -22601,7 +24258,7 @@ void JSStatWatcher::destroy(JSCell* cell)
 {
     static_cast<JSStatWatcher*>(cell)->JSStatWatcher::~JSStatWatcher();
 }
-
+  
 const ClassInfo JSStatWatcher::s_info = { "StatWatcher"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSStatWatcher) };
 
 void JSStatWatcher::finishCreation(VM& vm)
@@ -22610,38 +24267,37 @@ void JSStatWatcher::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSStatWatcher* JSStatWatcher::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSStatWatcher* ptr = new (NotNull, JSC::allocateCell<JSStatWatcher>(vm)) JSStatWatcher(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* StatWatcher__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSStatWatcher* JSStatWatcher::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSStatWatcher* ptr = new (NotNull, JSC::allocateCell<JSStatWatcher>(vm)) JSStatWatcher(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSStatWatcher* object = JSC::jsDynamicCast<JSStatWatcher*>(cell);
+extern "C" void* StatWatcher__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSStatWatcher* object = JSC::jsDynamicCast<JSStatWatcher*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool StatWatcher__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSStatWatcher* object = JSC::jsDynamicCast<JSStatWatcher*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool StatWatcher__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSStatWatcher* object = JSC::jsDynamicCast<JSStatWatcher*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t StatWatcher__ptrOffset = JSStatWatcher::offsetOfWrapped();
 
 void JSStatWatcher::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -22654,18 +24310,19 @@ void JSStatWatcher::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSStatWatcher::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSStatWatcherPrototype::create(vm, globalObject, JSStatWatcherPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue StatWatcher__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSStatWatcherStructure();
-    JSStatWatcher* instance = JSStatWatcher::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue StatWatcher__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSStatWatcherStructure();
+  JSStatWatcher* instance = JSStatWatcher::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -22674,7 +24331,7 @@ void JSStatWatcher::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSStatWatcher* thisObject = jsCast<JSStatWatcher*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -22683,17 +24340,17 @@ DEFINE_VISIT_CHILDREN(JSStatWatcher);
 template<typename Visitor>
 void JSStatWatcher::visitAdditionalChildren(Visitor& visitor)
 {
-    JSStatWatcher* thisObject = this;
+  JSStatWatcher* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_listener);
-
+    
     visitor.addOpaqueRoot(this->wrapped());
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSStatWatcher);
 
 template<typename Visitor>
-void JSStatWatcher::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSStatWatcher::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSStatWatcher* thisObject = jsCast<JSStatWatcher*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -22701,123 +24358,141 @@ void JSStatWatcher::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSStatWatcher);
-class JSStatsPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSStatsPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSStatsPrototype* ptr = new (NotNull, JSC::allocateCell<JSStatsPrototype>(vm)) JSStatsPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSStatsPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSStatsPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSStatsPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSStatsPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSStatsPrototype* ptr = new (NotNull, JSC::allocateCell<JSStatsPrototype>(vm)) JSStatsPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSStatsPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSStatsPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSStatsConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSStatsConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSStatsPrototype* prototype);
-
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
+    public:
+        using Base = JSC::InternalFunction;
+        static JSStatsConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSStatsPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSStatsConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForStatsConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForStatsConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForStatsConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForStatsConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSStatsPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSStatsConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSStatsPrototype* prototype);
+    };
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSStatsConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForStatsConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForStatsConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForStatsConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForStatsConstructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSStatsPrototype* prototype);
+extern "C" void* StatsClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsStatsConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSStatsConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSStatsPrototype* prototype);
-};
 
-extern "C" void* StatsClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsStatsConstructor);
 
 extern "C" void StatsClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__atime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__atimeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__atimeMs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__atimeMsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__birthtime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__birthtimeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__birthtimeMs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__birthtimeMsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__blksize(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__blksizeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__blocks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__blocksGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__ctime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__ctimeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__ctimeMs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__ctimeMsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__dev(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__devGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__gid(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__gidGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__ino(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__inoGetterWrap);
 
+
 extern "C" EncodedJSValue StatsPrototype__isBlockDevice_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatsPrototype__isBlockDeviceCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(StatsPrototype__isBlockDeviceWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue StatsPrototype__isBlockDevice_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue StatsPrototype__isBlockDevice_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isBlockDevice(StatsPrototype__isBlockDeviceWithoutTypeChecksWrapper,
-    JSStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isBlockDevice(StatsPrototype__isBlockDeviceWithoutTypeChecksWrapper, 
+  JSStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(StatsPrototype__isBlockDeviceWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -22832,13 +24507,14 @@ JSC_DEFINE_JIT_OPERATION(StatsPrototype__isBlockDeviceWithoutTypeChecksWrapper,
 extern "C" EncodedJSValue StatsPrototype__isCharacterDevice_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatsPrototype__isCharacterDeviceCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(StatsPrototype__isCharacterDeviceWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue StatsPrototype__isCharacterDevice_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue StatsPrototype__isCharacterDevice_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isCharacterDevice(StatsPrototype__isCharacterDeviceWithoutTypeChecksWrapper,
-    JSStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isCharacterDevice(StatsPrototype__isCharacterDeviceWithoutTypeChecksWrapper, 
+  JSStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(StatsPrototype__isCharacterDeviceWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -22853,13 +24529,14 @@ JSC_DEFINE_JIT_OPERATION(StatsPrototype__isCharacterDeviceWithoutTypeChecksWrapp
 extern "C" EncodedJSValue StatsPrototype__isDirectory_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatsPrototype__isDirectoryCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(StatsPrototype__isDirectoryWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue StatsPrototype__isDirectory_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue StatsPrototype__isDirectory_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isDirectory(StatsPrototype__isDirectoryWithoutTypeChecksWrapper,
-    JSStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isDirectory(StatsPrototype__isDirectoryWithoutTypeChecksWrapper, 
+  JSStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(StatsPrototype__isDirectoryWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -22874,13 +24551,14 @@ JSC_DEFINE_JIT_OPERATION(StatsPrototype__isDirectoryWithoutTypeChecksWrapper, En
 extern "C" EncodedJSValue StatsPrototype__isFIFO_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatsPrototype__isFIFOCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(StatsPrototype__isFIFOWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue StatsPrototype__isFIFO_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue StatsPrototype__isFIFO_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isFIFO(StatsPrototype__isFIFOWithoutTypeChecksWrapper,
-    JSStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isFIFO(StatsPrototype__isFIFOWithoutTypeChecksWrapper, 
+  JSStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(StatsPrototype__isFIFOWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -22895,13 +24573,14 @@ JSC_DEFINE_JIT_OPERATION(StatsPrototype__isFIFOWithoutTypeChecksWrapper, Encoded
 extern "C" EncodedJSValue StatsPrototype__isFile_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatsPrototype__isFileCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(StatsPrototype__isFileWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue StatsPrototype__isFile_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue StatsPrototype__isFile_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isFile(StatsPrototype__isFileWithoutTypeChecksWrapper,
-    JSStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isFile(StatsPrototype__isFileWithoutTypeChecksWrapper, 
+  JSStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(StatsPrototype__isFileWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -22916,13 +24595,14 @@ JSC_DEFINE_JIT_OPERATION(StatsPrototype__isFileWithoutTypeChecksWrapper, Encoded
 extern "C" EncodedJSValue StatsPrototype__isSocket_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatsPrototype__isSocketCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(StatsPrototype__isSocketWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue StatsPrototype__isSocket_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue StatsPrototype__isSocket_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isSocket(StatsPrototype__isSocketWithoutTypeChecksWrapper,
-    JSStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isSocket(StatsPrototype__isSocketWithoutTypeChecksWrapper, 
+  JSStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(StatsPrototype__isSocketWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -22937,13 +24617,14 @@ JSC_DEFINE_JIT_OPERATION(StatsPrototype__isSocketWithoutTypeChecksWrapper, Encod
 extern "C" EncodedJSValue StatsPrototype__isSymbolicLink_(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(StatsPrototype__isSymbolicLinkCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(StatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue));
-extern "C" EncodedJSValue StatsPrototype__isSymbolicLink_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+  extern "C" EncodedJSValue StatsPrototype__isSymbolicLink_WithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isSymbolicLink(StatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper,
-    JSStats::info(),
-    JSC::DOMJIT::Effect::forPure(),
-    JSC::SpecHeapTop);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForStatsPrototype__isSymbolicLink(StatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper, 
+  JSStats::info(), 
+  JSC::DOMJIT::Effect::forPure(), 
+  JSC::SpecHeapTop);
 
 JSC_DEFINE_JIT_OPERATION(StatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue))
 {
@@ -22958,56 +24639,68 @@ JSC_DEFINE_JIT_OPERATION(StatsPrototype__isSymbolicLinkWithoutTypeChecksWrapper,
 extern "C" JSC::EncodedJSValue StatsPrototype__mode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__modeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__mtime(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__mtimeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__mtimeMs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__mtimeMsGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__nlink(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__nlinkGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__rdev(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__rdevGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__size(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__sizeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue StatsPrototype__uid(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(StatsPrototype__uidGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSStatsPrototype, JSStatsPrototype::Base);
 
-static const HashTableValue JSStatsPrototypeTableValues[] = {
-    { "atime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__atimeGetterWrap, 0 } },
-    { "atimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__atimeMsGetterWrap, 0 } },
-    { "birthtime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__birthtimeGetterWrap, 0 } },
-    { "birthtimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__birthtimeMsGetterWrap, 0 } },
-    { "blksize"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__blksizeGetterWrap, 0 } },
-    { "blocks"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__blocksGetterWrap, 0 } },
-    { "ctime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__ctimeGetterWrap, 0 } },
-    { "ctimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__ctimeMsGetterWrap, 0 } },
-    { "dev"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__devGetterWrap, 0 } },
-    { "gid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__gidGetterWrap, 0 } },
-    { "ino"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__inoGetterWrap, 0 } },
-    { "isBlockDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isBlockDeviceCallback, &DOMJITSignatureForStatsPrototype__isBlockDevice } },
-    { "isCharacterDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isCharacterDeviceCallback, &DOMJITSignatureForStatsPrototype__isCharacterDevice } },
-    { "isDirectory"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isDirectoryCallback, &DOMJITSignatureForStatsPrototype__isDirectory } },
-    { "isFIFO"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isFIFOCallback, &DOMJITSignatureForStatsPrototype__isFIFO } },
-    { "isFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isFileCallback, &DOMJITSignatureForStatsPrototype__isFile } },
-    { "isSocket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isSocketCallback, &DOMJITSignatureForStatsPrototype__isSocket } },
-    { "isSymbolicLink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isSymbolicLinkCallback, &DOMJITSignatureForStatsPrototype__isSymbolicLink } },
-    { "mode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__modeGetterWrap, 0 } },
-    { "mtime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__mtimeGetterWrap, 0 } },
-    { "mtimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__mtimeMsGetterWrap, 0 } },
-    { "nlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__nlinkGetterWrap, 0 } },
-    { "rdev"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__rdevGetterWrap, 0 } },
-    { "size"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__sizeGetterWrap, 0 } },
-    { "uid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__uidGetterWrap, 0 } }
+
+  static const HashTableValue JSStatsPrototypeTableValues[] = {
+{ "atime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__atimeGetterWrap, 0 } }  ,
+{ "atimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__atimeMsGetterWrap, 0 } }  ,
+{ "birthtime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__birthtimeGetterWrap, 0 } }  ,
+{ "birthtimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__birthtimeMsGetterWrap, 0 } }  ,
+{ "blksize"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__blksizeGetterWrap, 0 } }  ,
+{ "blocks"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__blocksGetterWrap, 0 } }  ,
+{ "ctime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__ctimeGetterWrap, 0 } }  ,
+{ "ctimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__ctimeMsGetterWrap, 0 } }  ,
+{ "dev"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__devGetterWrap, 0 } }  ,
+{ "gid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__gidGetterWrap, 0 } }  ,
+{ "ino"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__inoGetterWrap, 0 } }  ,
+{ "isBlockDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isBlockDeviceCallback, &DOMJITSignatureForStatsPrototype__isBlockDevice } }  ,
+{ "isCharacterDevice"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isCharacterDeviceCallback, &DOMJITSignatureForStatsPrototype__isCharacterDevice } }  ,
+{ "isDirectory"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isDirectoryCallback, &DOMJITSignatureForStatsPrototype__isDirectory } }  ,
+{ "isFIFO"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isFIFOCallback, &DOMJITSignatureForStatsPrototype__isFIFO } }  ,
+{ "isFile"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isFileCallback, &DOMJITSignatureForStatsPrototype__isFile } }  ,
+{ "isSocket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isSocketCallback, &DOMJITSignatureForStatsPrototype__isSocket } }  ,
+{ "isSymbolicLink"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontEnum | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, StatsPrototype__isSymbolicLinkCallback, &DOMJITSignatureForStatsPrototype__isSymbolicLink } }  ,
+{ "mode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__modeGetterWrap, 0 } }  ,
+{ "mtime"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__mtimeGetterWrap, 0 } }  ,
+{ "mtimeMs"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__mtimeMsGetterWrap, 0 } }  ,
+{ "nlink"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__nlinkGetterWrap, 0 } }  ,
+{ "rdev"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__rdevGetterWrap, 0 } }  ,
+{ "size"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__sizeGetterWrap, 0 } }  ,
+{ "uid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, StatsPrototype__uidGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSStatsPrototype::s_info = { "Stats"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSStatsPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsStatsConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -23018,43 +24711,49 @@ JSC_DEFINE_CUSTOM_GETTER(jsStatsConstructor, (JSGlobalObject * lexicalGlobalObje
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Stats"_s);
     return JSValue::encode(globalObject->JSStatsConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__atimeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_atime.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        StatsPrototype__atime(thisObject->wrapped(), globalObject));
+        StatsPrototype__atime(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_atime.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void StatsPrototype__atimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
-    thisObject->m_atime.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue StatsPrototype__atimeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void StatsPrototype__atimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
+      thisObject->m_atime.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue StatsPrototype__atimeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_atime.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__atimeMsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23062,11 +24761,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__atimeMsGetterWrap, (JSGlobalObject * le
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__birthtimeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23074,11 +24774,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__birthtimeGetterWrap, (JSGlobalObject *
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__birthtimeMsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23086,11 +24787,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__birthtimeMsGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__blksizeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23098,11 +24800,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__blksizeGetterWrap, (JSGlobalObject * le
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__blocksGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23110,42 +24813,47 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__blocksGetterWrap, (JSGlobalObject * lex
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__ctimeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_ctime.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        StatsPrototype__ctime(thisObject->wrapped(), globalObject));
+        StatsPrototype__ctime(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_ctime.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void StatsPrototype__ctimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
-    thisObject->m_ctime.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue StatsPrototype__ctimeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void StatsPrototype__ctimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
+      thisObject->m_ctime.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue StatsPrototype__ctimeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_ctime.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__ctimeMsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23153,11 +24861,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__ctimeMsGetterWrap, (JSGlobalObject * le
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__devGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23165,11 +24874,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__devGetterWrap, (JSGlobalObject * lexica
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__gidGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23177,11 +24887,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__gidGetterWrap, (JSGlobalObject * lexica
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__inoGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23189,207 +24900,215 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__inoGetterWrap, (JSGlobalObject * lexica
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isBlockDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isBlockDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
+        JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatsPrototype__isBlockDevice_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return StatsPrototype__isBlockDevice_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isCharacterDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isCharacterDeviceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
 
-    JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatsPrototype__isCharacterDevice_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return StatsPrototype__isCharacterDevice_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isDirectoryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isDirectoryCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
 
-    JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatsPrototype__isDirectory_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return StatsPrototype__isDirectory_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isFIFOCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isFIFOCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
 
-    JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatsPrototype__isFIFO_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return StatsPrototype__isFIFO_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isFileCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
 
-    JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatsPrototype__isFile_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return StatsPrototype__isFile_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isSocketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isSocketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
 
-    JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatsPrototype__isSocket_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return StatsPrototype__isSocket_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isSymbolicLinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(StatsPrototype__isSymbolicLinkCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
 
-    JSStats* thisObject = jsDynamicCast<JSStats*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Stats"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return StatsPrototype__isSymbolicLink_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return StatsPrototype__isSymbolicLink_(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__modeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23397,42 +25116,47 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__modeGetterWrap, (JSGlobalObject * lexic
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__mtimeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_mtime.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        StatsPrototype__mtime(thisObject->wrapped(), globalObject));
+        StatsPrototype__mtime(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_mtime.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void StatsPrototype__mtimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
-    thisObject->m_mtime.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue StatsPrototype__mtimeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void StatsPrototype__mtimeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
+      thisObject->m_mtime.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue StatsPrototype__mtimeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_mtime.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__mtimeMsGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23440,11 +25164,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__mtimeMsGetterWrap, (JSGlobalObject * le
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__nlinkGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23452,11 +25177,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__nlinkGetterWrap, (JSGlobalObject * lexi
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__rdevGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23464,11 +25190,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__rdevGetterWrap, (JSGlobalObject * lexic
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__sizeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23476,11 +25203,12 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__sizeGetterWrap, (JSGlobalObject * lexic
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__uidGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSStats* thisObject = jsCast<JSStats*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23488,6 +25216,7 @@ JSC_DEFINE_CUSTOM_GETTER(StatsPrototype__uidGetterWrap, (JSGlobalObject * lexica
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 void JSStatsPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -23499,64 +25228,67 @@ void JSStatsPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalOb
 void JSStatsConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSStatsPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "Stats"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSStatsConstructor::JSStatsConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSStatsConstructor::JSStatsConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSStatsConstructor* JSStatsConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSStatsPrototype* prototype)
-{
+  }
+
+JSStatsConstructor* JSStatsConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSStatsPrototype* prototype) {
     JSStatsConstructor* ptr = new (NotNull, JSC::allocateCell<JSStatsConstructor>(vm)) JSStatsConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSStatsConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSStatsConstructor();
     Structure* structure = globalObject->JSStatsStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSStatsStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSStatsStructure()
+      );
     }
 
     void* ptr = StatsClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSStats* instance = JSStats::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSStatsConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSStatsPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSStatsConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSStatsConstructor) };
 
-extern "C" EncodedJSValue Stats__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue Stats__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSStatsConstructor());
-}
+  }
 
 JSStats::~JSStats()
 {
@@ -23568,7 +25300,7 @@ void JSStats::destroy(JSCell* cell)
 {
     static_cast<JSStats*>(cell)->JSStats::~JSStats();
 }
-
+  
 const ClassInfo JSStats::s_info = { "Stats"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSStats) };
 
 void JSStats::finishCreation(VM& vm)
@@ -23577,38 +25309,37 @@ void JSStats::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSStats* JSStats::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSStats* ptr = new (NotNull, JSC::allocateCell<JSStats>(vm)) JSStats(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Stats__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSStats* JSStats::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSStats* ptr = new (NotNull, JSC::allocateCell<JSStats>(vm)) JSStats(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSStats* object = JSC::jsDynamicCast<JSStats*>(cell);
+extern "C" void* Stats__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSStats* object = JSC::jsDynamicCast<JSStats*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Stats__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSStats* object = JSC::jsDynamicCast<JSStats*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Stats__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSStats* object = JSC::jsDynamicCast<JSStats*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Stats__ptrOffset = JSStats::offsetOfWrapped();
 
 void JSStats::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -23623,7 +25354,7 @@ void JSStats::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSStats::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSStatsConstructor::create(vm, globalObject, WebCore::JSStatsConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSStatsPrototype*>(prototype));
+  return WebCore::JSStatsConstructor::create(vm, globalObject, WebCore::JSStatsConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSStatsPrototype*>(prototype));
 }
 
 JSObject* JSStats::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -23631,13 +25362,12 @@ JSObject* JSStats::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSStatsPrototype::create(vm, globalObject, JSStatsPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Stats__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSStatsStructure();
-    JSStats* instance = JSStats::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Stats__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSStatsStructure();
+  JSStats* instance = JSStats::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -23646,7 +25376,7 @@ void JSStats::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSStats* thisObject = jsCast<JSStats*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -23655,18 +25385,19 @@ DEFINE_VISIT_CHILDREN(JSStats);
 template<typename Visitor>
 void JSStats::visitAdditionalChildren(Visitor& visitor)
 {
-    JSStats* thisObject = this;
+  JSStats* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_atime);
+    
+        visitor.append(thisObject->m_atime);
     visitor.append(thisObject->m_ctime);
     visitor.append(thisObject->m_mtime);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSStats);
 
 template<typename Visitor>
-void JSStats::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSStats::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSStats* thisObject = jsCast<JSStats*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -23674,106 +25405,130 @@ void JSStats::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSStats);
-class JSSubprocessPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSSubprocessPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSSubprocessPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSSubprocessPrototype* ptr = new (NotNull, JSC::allocateCell<JSSubprocessPrototype>(vm)) JSSubprocessPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSubprocessPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSSubprocessPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSSubprocessPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSSubprocessPrototype* ptr = new (NotNull, JSC::allocateCell<JSSubprocessPrototype>(vm)) JSSubprocessPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* SubprocessClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsSubprocessConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSubprocessPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSSubprocessPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* SubprocessClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsSubprocessConstructor);
 
 extern "C" void SubprocessClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getExitCode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__exitCodeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getExited(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__exitedGetterWrap);
 
+
 extern "C" EncodedJSValue SubprocessPrototype__kill(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SubprocessPrototype__killCallback);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getKilled(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__killedGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getPid(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__pidGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getStdout(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__readableGetterWrap);
 
+
 extern "C" EncodedJSValue SubprocessPrototype__doRef(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SubprocessPrototype__refCallback);
 
+
 extern "C" EncodedJSValue SubprocessPrototype__doSend(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SubprocessPrototype__sendCallback);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getSignalCode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__signalCodeGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getStderr(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__stderrGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getStdin(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__stdinGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getStdout(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__stdoutGetterWrap);
 
+
 extern "C" EncodedJSValue SubprocessPrototype__doUnref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(SubprocessPrototype__unrefCallback);
 
+
 extern "C" JSC::EncodedJSValue SubprocessPrototype__getStdin(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(SubprocessPrototype__writableGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSSubprocessPrototype, JSSubprocessPrototype::Base);
 
-static const HashTableValue JSSubprocessPrototypeTableValues[] = {
-    { "exitCode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__exitCodeGetterWrap, 0 } },
-    { "exited"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__exitedGetterWrap, 0 } },
-    { "kill"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SubprocessPrototype__killCallback, 1 } },
-    { "killed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__killedGetterWrap, 0 } },
-    { "pid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__pidGetterWrap, 0 } },
-    { "readable"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__readableGetterWrap, 0 } },
-    { "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SubprocessPrototype__refCallback, 0 } },
-    { "send"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SubprocessPrototype__sendCallback, 1 } },
-    { "signalCode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__signalCodeGetterWrap, 0 } },
-    { "stderr"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__stderrGetterWrap, 0 } },
-    { "stdin"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__stdinGetterWrap, 0 } },
-    { "stdout"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__stdoutGetterWrap, 0 } },
-    { "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SubprocessPrototype__unrefCallback, 0 } },
-    { "writable"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__writableGetterWrap, 0 } }
+
+  static const HashTableValue JSSubprocessPrototypeTableValues[] = {
+{ "exitCode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__exitCodeGetterWrap, 0 } }  ,
+{ "exited"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__exitedGetterWrap, 0 } }  ,
+{ "kill"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SubprocessPrototype__killCallback, 1 } }  ,
+{ "killed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__killedGetterWrap, 0 } }  ,
+{ "pid"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__pidGetterWrap, 0 } }  ,
+{ "readable"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__readableGetterWrap, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SubprocessPrototype__refCallback, 0 } }  ,
+{ "send"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SubprocessPrototype__sendCallback, 1 } }  ,
+{ "signalCode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__signalCodeGetterWrap, 0 } }  ,
+{ "stderr"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__stderrGetterWrap, 0 } }  ,
+{ "stdin"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__stdinGetterWrap, 0 } }  ,
+{ "stdout"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__stdoutGetterWrap, 0 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, SubprocessPrototype__unrefCallback, 0 } }  ,
+{ "writable"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, SubprocessPrototype__writableGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSSubprocessPrototype::s_info = { "Subprocess"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSubprocessPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsSubprocessConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -23784,12 +25539,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsSubprocessConstructor, (JSGlobalObject * lexicalGloba
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Subprocess"_s);
     return JSValue::encode(globalObject->JSSubprocessConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__exitCodeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23797,11 +25554,12 @@ JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__exitCodeGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__exitedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23809,39 +25567,41 @@ JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__exitedGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(SubprocessPrototype__killCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SubprocessPrototype__killCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSubprocess* thisObject = jsDynamicCast<JSSubprocess*>(callFrame->thisValue());
+        JSSubprocess* thisObject = jsDynamicCast<JSSubprocess*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Subprocess"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Subprocess"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return SubprocessPrototype__kill(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return SubprocessPrototype__kill(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__killedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23849,11 +25609,12 @@ JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__killedGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__pidGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23861,98 +25622,105 @@ JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__pidGetterWrap, (JSGlobalObject * l
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__readableGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_stdout.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        SubprocessPrototype__getStdout(thisObject->wrapped(), globalObject));
+        SubprocessPrototype__getStdout(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_stdout.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void SubprocessPrototype__readableSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    thisObject->m_stdout.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue SubprocessPrototype__readableGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void SubprocessPrototype__readableSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
+      thisObject->m_stdout.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue SubprocessPrototype__readableGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_stdout.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(SubprocessPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SubprocessPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSubprocess* thisObject = jsDynamicCast<JSSubprocess*>(callFrame->thisValue());
+        JSSubprocess* thisObject = jsDynamicCast<JSSubprocess*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Subprocess"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Subprocess"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return SubprocessPrototype__doRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return SubprocessPrototype__doRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(SubprocessPrototype__sendCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(SubprocessPrototype__sendCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSSubprocess* thisObject = jsDynamicCast<JSSubprocess*>(callFrame->thisValue());
 
-    JSSubprocess* thisObject = jsDynamicCast<JSSubprocess*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Subprocess"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Subprocess"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return SubprocessPrototype__doSend(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return SubprocessPrototype__doSend(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__signalCodeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -23960,158 +25728,176 @@ JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__signalCodeGetterWrap, (JSGlobalObj
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__stderrGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_stderr.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        SubprocessPrototype__getStderr(thisObject->wrapped(), globalObject));
+        SubprocessPrototype__getStderr(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_stderr.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void SubprocessPrototype__stderrSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    thisObject->m_stderr.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue SubprocessPrototype__stderrGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void SubprocessPrototype__stderrSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
+      thisObject->m_stderr.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue SubprocessPrototype__stderrGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_stderr.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__stdinGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_stdin.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        SubprocessPrototype__getStdin(thisObject->wrapped(), globalObject));
+        SubprocessPrototype__getStdin(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_stdin.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void SubprocessPrototype__stdinSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    thisObject->m_stdin.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue SubprocessPrototype__stdinGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void SubprocessPrototype__stdinSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
+      thisObject->m_stdin.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue SubprocessPrototype__stdinGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_stdin.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__stdoutGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_stdout.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        SubprocessPrototype__getStdout(thisObject->wrapped(), globalObject));
+        SubprocessPrototype__getStdout(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_stdout.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void SubprocessPrototype__stdoutSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    thisObject->m_stdout.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue SubprocessPrototype__stdoutGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void SubprocessPrototype__stdoutSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
+      thisObject->m_stdout.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue SubprocessPrototype__stdoutGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_stdout.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(SubprocessPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(SubprocessPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSSubprocess* thisObject = jsDynamicCast<JSSubprocess*>(callFrame->thisValue());
+        JSSubprocess* thisObject = jsDynamicCast<JSSubprocess*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Subprocess"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Subprocess"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return SubprocessPrototype__doUnref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return SubprocessPrototype__doUnref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(SubprocessPrototype__writableGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_stdin.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        SubprocessPrototype__getStdin(thisObject->wrapped(), globalObject));
+        SubprocessPrototype__getStdin(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_stdin.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void SubprocessPrototype__writableSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
-    thisObject->m_stdin.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue SubprocessPrototype__writableGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void SubprocessPrototype__writableSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
+      thisObject->m_stdin.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue SubprocessPrototype__writableGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSSubprocess*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_stdin.get());
-}
+  }
+  
+  
 
 void JSSubprocessPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -24121,10 +25907,9 @@ void JSSubprocessPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* glo
 }
 
 extern "C" bool Subprocess__hasPendingActivity(void* ptr);
-bool JSSubprocess::hasPendingActivity(void* ctx)
-{
-    return Subprocess__hasPendingActivity(ctx);
-}
+    bool JSSubprocess::hasPendingActivity(void* ctx) {
+        return Subprocess__hasPendingActivity(ctx);
+    }
 
 JSSubprocess::~JSSubprocess()
 {
@@ -24136,7 +25921,7 @@ void JSSubprocess::destroy(JSCell* cell)
 {
     static_cast<JSSubprocess*>(cell)->JSSubprocess::~JSSubprocess();
 }
-
+  
 const ClassInfo JSSubprocess::s_info = { "Subprocess"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSubprocess) };
 
 void JSSubprocess::finishCreation(VM& vm)
@@ -24145,38 +25930,37 @@ void JSSubprocess::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSSubprocess* JSSubprocess::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSSubprocess* ptr = new (NotNull, JSC::allocateCell<JSSubprocess>(vm)) JSSubprocess(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Subprocess__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSSubprocess* JSSubprocess::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSSubprocess* ptr = new (NotNull, JSC::allocateCell<JSSubprocess>(vm)) JSSubprocess(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSSubprocess* object = JSC::jsDynamicCast<JSSubprocess*>(cell);
+extern "C" void* Subprocess__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSSubprocess* object = JSC::jsDynamicCast<JSSubprocess*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Subprocess__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSSubprocess* object = JSC::jsDynamicCast<JSSubprocess*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Subprocess__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSSubprocess* object = JSC::jsDynamicCast<JSSubprocess*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Subprocess__ptrOffset = JSSubprocess::offsetOfWrapped();
 
 void JSSubprocess::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -24189,18 +25973,19 @@ void JSSubprocess::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSSubprocess::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSSubprocessPrototype::create(vm, globalObject, JSSubprocessPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Subprocess__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSSubprocessStructure();
-    JSSubprocess* instance = JSSubprocess::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Subprocess__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSSubprocessStructure();
+  JSSubprocess* instance = JSSubprocess::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -24209,7 +25994,7 @@ void JSSubprocess::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -24218,10 +26003,10 @@ DEFINE_VISIT_CHILDREN(JSSubprocess);
 template<typename Visitor>
 void JSSubprocess::visitAdditionalChildren(Visitor& visitor)
 {
-    JSSubprocess* thisObject = this;
+  JSSubprocess* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_stderr);
+    
+        visitor.append(thisObject->m_stderr);
     visitor.append(thisObject->m_stdin);
     visitor.append(thisObject->m_stdout);
     visitor.addOpaqueRoot(this->wrapped());
@@ -24230,7 +26015,7 @@ void JSSubprocess::visitAdditionalChildren(Visitor& visitor)
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSSubprocess);
 
 template<typename Visitor>
-void JSSubprocess::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSSubprocess::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSSubprocess* thisObject = jsCast<JSSubprocess*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -24238,177 +26023,219 @@ void JSSubprocess::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSSubprocess);
-class JSTCPSocketPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSTCPSocketPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSTCPSocketPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSTCPSocketPrototype* ptr = new (NotNull, JSC::allocateCell<JSTCPSocketPrototype>(vm)) JSTCPSocketPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTCPSocketPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSTCPSocketPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSTCPSocketPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSTCPSocketPrototype* ptr = new (NotNull, JSC::allocateCell<JSTCPSocketPrototype>(vm)) JSTCPSocketPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* TCPSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsTCPSocketConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTCPSocketPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSTCPSocketPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* TCPSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsTCPSocketConstructor);
 
 extern "C" void TCPSocketClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue TCPSocketPrototype__getALPNProtocol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__alpnProtocolGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TCPSocketPrototype__getAuthorized(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__authorizedGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TCPSocketPrototype__getData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__dataGetterWrap);
 
+
 extern "C" bool TCPSocketPrototype__setData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
 JSC_DECLARE_CUSTOM_SETTER(TCPSocketPrototype__dataSetterWrap);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__end(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__endCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__exportKeyingMaterial(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__exportKeyingMaterialCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__flush(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__flushCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getAuthorizationError(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getAuthorizationErrorCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getCertificate(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getCertificateCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getCipher(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getCipherCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getEphemeralKeyInfo(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getEphemeralKeyInfoCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getPeerCertificate(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getPeerCertificateCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getSession(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getSessionCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getSharedSigalgs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getSharedSigalgsCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getTLSFinishedMessage(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getTLSFinishedMessageCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getTLSPeerFinishedMessage(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getTLSPeerFinishedMessageCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getTLSTicket(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getTLSTicketCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__getTLSVersion(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__getTLSVersionCallback);
 
+
 extern "C" JSC::EncodedJSValue TCPSocketPrototype__getListener(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__listenerGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TCPSocketPrototype__getLocalPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__localPortGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TCPSocketPrototype__getReadyState(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__readyStateGetterWrap);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__ref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__refCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__reload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__reloadCallback);
 
+
 extern "C" JSC::EncodedJSValue TCPSocketPrototype__getRemoteAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__remoteAddressGetterWrap);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__setMaxSendFragment(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__setMaxSendFragmentCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__setServername(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__setServernameCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__setSession(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__setSessionCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__shutdown(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__shutdownCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__timeout(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__timeoutCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__unref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__unrefCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__upgradeTLS(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__upgradeTLSCallback);
 
+
 extern "C" EncodedJSValue TCPSocketPrototype__write(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__writeCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTCPSocketPrototype, JSTCPSocketPrototype::Base);
 
-static const HashTableValue JSTCPSocketPrototypeTableValues[] = {
-    { "alpnProtocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__alpnProtocolGetterWrap, 0 } },
-    { "authorized"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__authorizedGetterWrap, 0 } },
-    { "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__dataGetterWrap, TCPSocketPrototype__dataSetterWrap } },
-    { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__endCallback, 3 } },
-    { "exportKeyingMaterial"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__exportKeyingMaterialCallback, 3 } },
-    { "flush"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__flushCallback, 0 } },
-    { "getAuthorizationError"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getAuthorizationErrorCallback, 0 } },
-    { "getCertificate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getCertificateCallback, 0 } },
-    { "getCipher"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getCipherCallback, 0 } },
-    { "getEphemeralKeyInfo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getEphemeralKeyInfoCallback, 0 } },
-    { "getPeerCertificate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getPeerCertificateCallback, 1 } },
-    { "getSession"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getSessionCallback, 0 } },
-    { "getSharedSigalgs"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getSharedSigalgsCallback, 0 } },
-    { "getTLSFinishedMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getTLSFinishedMessageCallback, 0 } },
-    { "getTLSPeerFinishedMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getTLSPeerFinishedMessageCallback, 0 } },
-    { "getTLSTicket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getTLSTicketCallback, 0 } },
-    { "getTLSVersion"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getTLSVersionCallback, 0 } },
-    { "listener"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__listenerGetterWrap, 0 } },
-    { "localPort"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__localPortGetterWrap, 0 } },
-    { "readyState"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__readyStateGetterWrap, 0 } },
-    { "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__refCallback, 0 } },
-    { "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__reloadCallback, 1 } },
-    { "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__remoteAddressGetterWrap, 0 } },
-    { "setMaxSendFragment"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__setMaxSendFragmentCallback, 1 } },
-    { "setServername"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__setServernameCallback, 1 } },
-    { "setSession"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__setSessionCallback, 0 } },
-    { "shutdown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__shutdownCallback, 1 } },
-    { "timeout"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__timeoutCallback, 1 } },
-    { "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__unrefCallback, 0 } },
-    { "upgradeTLS"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__upgradeTLSCallback, 1 } },
-    { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__writeCallback, 3 } }
+
+  static const HashTableValue JSTCPSocketPrototypeTableValues[] = {
+{ "alpnProtocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__alpnProtocolGetterWrap, 0 } }  ,
+{ "authorized"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__authorizedGetterWrap, 0 } }  ,
+{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__dataGetterWrap, TCPSocketPrototype__dataSetterWrap } }  ,
+{ "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__endCallback, 3 } }  ,
+{ "exportKeyingMaterial"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__exportKeyingMaterialCallback, 3 } }  ,
+{ "flush"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__flushCallback, 0 } }  ,
+{ "getAuthorizationError"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getAuthorizationErrorCallback, 0 } }  ,
+{ "getCertificate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getCertificateCallback, 0 } }  ,
+{ "getCipher"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getCipherCallback, 0 } }  ,
+{ "getEphemeralKeyInfo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getEphemeralKeyInfoCallback, 0 } }  ,
+{ "getPeerCertificate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getPeerCertificateCallback, 1 } }  ,
+{ "getSession"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getSessionCallback, 0 } }  ,
+{ "getSharedSigalgs"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getSharedSigalgsCallback, 0 } }  ,
+{ "getTLSFinishedMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getTLSFinishedMessageCallback, 0 } }  ,
+{ "getTLSPeerFinishedMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getTLSPeerFinishedMessageCallback, 0 } }  ,
+{ "getTLSTicket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getTLSTicketCallback, 0 } }  ,
+{ "getTLSVersion"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__getTLSVersionCallback, 0 } }  ,
+{ "listener"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__listenerGetterWrap, 0 } }  ,
+{ "localPort"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__localPortGetterWrap, 0 } }  ,
+{ "readyState"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__readyStateGetterWrap, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__refCallback, 0 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__reloadCallback, 1 } }  ,
+{ "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__remoteAddressGetterWrap, 0 } }  ,
+{ "setMaxSendFragment"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__setMaxSendFragmentCallback, 1 } }  ,
+{ "setServername"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__setServernameCallback, 1 } }  ,
+{ "setSession"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__setSessionCallback, 0 } }  ,
+{ "shutdown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__shutdownCallback, 1 } }  ,
+{ "timeout"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__timeoutCallback, 1 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__unrefCallback, 0 } }  ,
+{ "upgradeTLS"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__upgradeTLSCallback, 1 } }  ,
+{ "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__writeCallback, 3 } }
 };
 
+
+
 const ClassInfo JSTCPSocketPrototype::s_info = { "TCPSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTCPSocketPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsTCPSocketConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -24419,12 +26246,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsTCPSocketConstructor, (JSGlobalObject * lexicalGlobal
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for TCPSocket"_s);
     return JSValue::encode(globalObject->JSTCPSocketConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__alpnProtocolGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -24432,11 +26261,12 @@ JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__alpnProtocolGetterWrap, (JSGlobalOb
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__authorizedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -24444,37 +26274,42 @@ JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__authorizedGetterWrap, (JSGlobalObje
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__dataGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_data.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        TCPSocketPrototype__getData(thisObject->wrapped(), globalObject));
+        TCPSocketPrototype__getData(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_data.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void TCPSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
-    thisObject->m_data.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue TCPSocketPrototype__dataGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void TCPSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+      thisObject->m_data.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue TCPSocketPrototype__dataGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_data.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_SETTER(TCPSocketPrototype__dataSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
 {
@@ -24487,402 +26322,417 @@ JSC_DEFINE_CUSTOM_SETTER(TCPSocketPrototype__dataSetterWrap, (JSGlobalObject * l
     RELEASE_AND_RETURN(throwScope, result);
 }
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__endCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__endCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return TCPSocketPrototype__end(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__end(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__exportKeyingMaterialCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__exportKeyingMaterialCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__exportKeyingMaterial(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__exportKeyingMaterial(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__flushCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__flushCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__flush(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__flush(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getAuthorizationErrorCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getAuthorizationErrorCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getAuthorizationError(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getAuthorizationError(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getCertificateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getCertificateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getCertificate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getCertificate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getCipherCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getCipherCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getCipher(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getCipher(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getEphemeralKeyInfoCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getEphemeralKeyInfoCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getEphemeralKeyInfo(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getEphemeralKeyInfo(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getPeerCertificateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getPeerCertificateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getPeerCertificate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getPeerCertificate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getSessionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getSessionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getSession(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getSession(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getSharedSigalgsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getSharedSigalgsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getSharedSigalgs(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getSharedSigalgs(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getTLSFinishedMessageCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getTLSFinishedMessageCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getTLSFinishedMessage(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getTLSFinishedMessage(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getTLSPeerFinishedMessageCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getTLSPeerFinishedMessageCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getTLSPeerFinishedMessage(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getTLSPeerFinishedMessage(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getTLSTicketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getTLSTicketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getTLSTicket(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__getTLSTicket(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getTLSVersionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__getTLSVersionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__getTLSVersion(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TCPSocketPrototype__getTLSVersion(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__listenerGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -24890,11 +26740,12 @@ JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__listenerGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__localPortGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -24902,11 +26753,12 @@ JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__localPortGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__readyStateGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -24914,317 +26766,332 @@ JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__readyStateGetterWrap, (JSGlobalObje
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return TCPSocketPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TCPSocketPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__remoteAddressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_remoteAddress.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        TCPSocketPrototype__getRemoteAddress(thisObject->wrapped(), globalObject));
+        TCPSocketPrototype__getRemoteAddress(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_remoteAddress.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void TCPSocketPrototype__remoteAddressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
-    thisObject->m_remoteAddress.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue TCPSocketPrototype__remoteAddressGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void TCPSocketPrototype__remoteAddressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+      thisObject->m_remoteAddress.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue TCPSocketPrototype__remoteAddressGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_remoteAddress.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__setMaxSendFragmentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__setMaxSendFragmentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__setMaxSendFragment(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__setMaxSendFragment(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__setServernameCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__setServernameCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__setServername(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__setServername(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__setSessionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__setSessionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__setSession(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__setSession(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__shutdownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__shutdownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__shutdown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__shutdown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__timeoutCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__timeoutCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__timeout(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__timeout(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__upgradeTLSCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__upgradeTLSCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__upgradeTLS(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TCPSocketPrototype__upgradeTLS(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__writeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__writeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
 
-    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TCPSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TCPSocketPrototype__write(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TCPSocketPrototype__write(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSTCPSocketPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -25234,10 +27101,9 @@ void JSTCPSocketPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* glob
 }
 
 extern "C" bool TCPSocket__hasPendingActivity(void* ptr);
-bool JSTCPSocket::hasPendingActivity(void* ctx)
-{
-    return TCPSocket__hasPendingActivity(ctx);
-}
+    bool JSTCPSocket::hasPendingActivity(void* ctx) {
+        return TCPSocket__hasPendingActivity(ctx);
+    }
 
 JSTCPSocket::~JSTCPSocket()
 {
@@ -25249,7 +27115,7 @@ void JSTCPSocket::destroy(JSCell* cell)
 {
     static_cast<JSTCPSocket*>(cell)->JSTCPSocket::~JSTCPSocket();
 }
-
+  
 const ClassInfo JSTCPSocket::s_info = { "TCPSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTCPSocket) };
 
 void JSTCPSocket::finishCreation(VM& vm)
@@ -25258,38 +27124,37 @@ void JSTCPSocket::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSTCPSocket* JSTCPSocket::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSTCPSocket* ptr = new (NotNull, JSC::allocateCell<JSTCPSocket>(vm)) JSTCPSocket(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* TCPSocket__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSTCPSocket* JSTCPSocket::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSTCPSocket* ptr = new (NotNull, JSC::allocateCell<JSTCPSocket>(vm)) JSTCPSocket(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSTCPSocket* object = JSC::jsDynamicCast<JSTCPSocket*>(cell);
+extern "C" void* TCPSocket__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSTCPSocket* object = JSC::jsDynamicCast<JSTCPSocket*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool TCPSocket__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSTCPSocket* object = JSC::jsDynamicCast<JSTCPSocket*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool TCPSocket__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSTCPSocket* object = JSC::jsDynamicCast<JSTCPSocket*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t TCPSocket__ptrOffset = JSTCPSocket::offsetOfWrapped();
 
 void JSTCPSocket::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -25302,18 +27167,19 @@ void JSTCPSocket::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSTCPSocket::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSTCPSocketPrototype::create(vm, globalObject, JSTCPSocketPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue TCPSocket__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSTCPSocketStructure();
-    JSTCPSocket* instance = JSTCPSocket::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue TCPSocket__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSTCPSocketStructure();
+  JSTCPSocket* instance = JSTCPSocket::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -25322,7 +27188,7 @@ void JSTCPSocket::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -25331,10 +27197,10 @@ DEFINE_VISIT_CHILDREN(JSTCPSocket);
 template<typename Visitor>
 void JSTCPSocket::visitAdditionalChildren(Visitor& visitor)
 {
-    JSTCPSocket* thisObject = this;
+  JSTCPSocket* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_data);
+    
+        visitor.append(thisObject->m_data);
     visitor.append(thisObject->m_remoteAddress);
     visitor.addOpaqueRoot(this->wrapped());
 }
@@ -25342,7 +27208,7 @@ void JSTCPSocket::visitAdditionalChildren(Visitor& visitor)
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSTCPSocket);
 
 template<typename Visitor>
-void JSTCPSocket::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSTCPSocket::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -25350,177 +27216,219 @@ void JSTCPSocket::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSTCPSocket);
-class JSTLSSocketPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSTLSSocketPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSTLSSocketPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSTLSSocketPrototype* ptr = new (NotNull, JSC::allocateCell<JSTLSSocketPrototype>(vm)) JSTLSSocketPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTLSSocketPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSTLSSocketPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSTLSSocketPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSTLSSocketPrototype* ptr = new (NotNull, JSC::allocateCell<JSTLSSocketPrototype>(vm)) JSTLSSocketPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* TLSSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsTLSSocketConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTLSSocketPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSTLSSocketPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* TLSSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsTLSSocketConstructor);
 
 extern "C" void TLSSocketClass__finalize(void*);
 
+
 extern "C" JSC::EncodedJSValue TLSSocketPrototype__getALPNProtocol(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__alpnProtocolGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TLSSocketPrototype__getAuthorized(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__authorizedGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TLSSocketPrototype__getData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__dataGetterWrap);
 
+
 extern "C" bool TLSSocketPrototype__setData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
 JSC_DECLARE_CUSTOM_SETTER(TLSSocketPrototype__dataSetterWrap);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__end(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__endCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__exportKeyingMaterial(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__exportKeyingMaterialCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__flush(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__flushCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getAuthorizationError(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getAuthorizationErrorCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getCertificate(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getCertificateCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getCipher(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getCipherCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getEphemeralKeyInfo(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getEphemeralKeyInfoCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getPeerCertificate(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getPeerCertificateCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getSession(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getSessionCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getSharedSigalgs(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getSharedSigalgsCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getTLSFinishedMessage(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getTLSFinishedMessageCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getTLSPeerFinishedMessage(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getTLSPeerFinishedMessageCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getTLSTicket(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getTLSTicketCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__getTLSVersion(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__getTLSVersionCallback);
 
+
 extern "C" JSC::EncodedJSValue TLSSocketPrototype__getListener(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__listenerGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TLSSocketPrototype__getLocalPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__localPortGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TLSSocketPrototype__getReadyState(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__readyStateGetterWrap);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__ref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__refCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__reload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__reloadCallback);
 
+
 extern "C" JSC::EncodedJSValue TLSSocketPrototype__getRemoteAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__remoteAddressGetterWrap);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__setMaxSendFragment(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__setMaxSendFragmentCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__setServername(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__setServernameCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__setSession(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__setSessionCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__shutdown(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__shutdownCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__timeout(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__timeoutCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__unref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__unrefCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__upgradeTLS(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__upgradeTLSCallback);
 
+
 extern "C" EncodedJSValue TLSSocketPrototype__write(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__writeCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTLSSocketPrototype, JSTLSSocketPrototype::Base);
 
-static const HashTableValue JSTLSSocketPrototypeTableValues[] = {
-    { "alpnProtocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__alpnProtocolGetterWrap, 0 } },
-    { "authorized"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__authorizedGetterWrap, 0 } },
-    { "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__dataGetterWrap, TLSSocketPrototype__dataSetterWrap } },
-    { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__endCallback, 3 } },
-    { "exportKeyingMaterial"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__exportKeyingMaterialCallback, 3 } },
-    { "flush"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__flushCallback, 0 } },
-    { "getAuthorizationError"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getAuthorizationErrorCallback, 0 } },
-    { "getCertificate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getCertificateCallback, 0 } },
-    { "getCipher"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getCipherCallback, 0 } },
-    { "getEphemeralKeyInfo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getEphemeralKeyInfoCallback, 0 } },
-    { "getPeerCertificate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getPeerCertificateCallback, 1 } },
-    { "getSession"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getSessionCallback, 0 } },
-    { "getSharedSigalgs"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getSharedSigalgsCallback, 0 } },
-    { "getTLSFinishedMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getTLSFinishedMessageCallback, 0 } },
-    { "getTLSPeerFinishedMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getTLSPeerFinishedMessageCallback, 0 } },
-    { "getTLSTicket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getTLSTicketCallback, 0 } },
-    { "getTLSVersion"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getTLSVersionCallback, 0 } },
-    { "listener"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__listenerGetterWrap, 0 } },
-    { "localPort"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__localPortGetterWrap, 0 } },
-    { "readyState"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__readyStateGetterWrap, 0 } },
-    { "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__refCallback, 0 } },
-    { "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__reloadCallback, 1 } },
-    { "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__remoteAddressGetterWrap, 0 } },
-    { "setMaxSendFragment"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__setMaxSendFragmentCallback, 1 } },
-    { "setServername"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__setServernameCallback, 1 } },
-    { "setSession"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__setSessionCallback, 0 } },
-    { "shutdown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__shutdownCallback, 1 } },
-    { "timeout"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__timeoutCallback, 1 } },
-    { "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__unrefCallback, 0 } },
-    { "upgradeTLS"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__upgradeTLSCallback, 1 } },
-    { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__writeCallback, 3 } }
+
+  static const HashTableValue JSTLSSocketPrototypeTableValues[] = {
+{ "alpnProtocol"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__alpnProtocolGetterWrap, 0 } }  ,
+{ "authorized"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__authorizedGetterWrap, 0 } }  ,
+{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__dataGetterWrap, TLSSocketPrototype__dataSetterWrap } }  ,
+{ "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__endCallback, 3 } }  ,
+{ "exportKeyingMaterial"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__exportKeyingMaterialCallback, 3 } }  ,
+{ "flush"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__flushCallback, 0 } }  ,
+{ "getAuthorizationError"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getAuthorizationErrorCallback, 0 } }  ,
+{ "getCertificate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getCertificateCallback, 0 } }  ,
+{ "getCipher"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getCipherCallback, 0 } }  ,
+{ "getEphemeralKeyInfo"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getEphemeralKeyInfoCallback, 0 } }  ,
+{ "getPeerCertificate"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getPeerCertificateCallback, 1 } }  ,
+{ "getSession"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getSessionCallback, 0 } }  ,
+{ "getSharedSigalgs"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getSharedSigalgsCallback, 0 } }  ,
+{ "getTLSFinishedMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getTLSFinishedMessageCallback, 0 } }  ,
+{ "getTLSPeerFinishedMessage"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getTLSPeerFinishedMessageCallback, 0 } }  ,
+{ "getTLSTicket"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getTLSTicketCallback, 0 } }  ,
+{ "getTLSVersion"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__getTLSVersionCallback, 0 } }  ,
+{ "listener"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__listenerGetterWrap, 0 } }  ,
+{ "localPort"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__localPortGetterWrap, 0 } }  ,
+{ "readyState"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__readyStateGetterWrap, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__refCallback, 0 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__reloadCallback, 1 } }  ,
+{ "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__remoteAddressGetterWrap, 0 } }  ,
+{ "setMaxSendFragment"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__setMaxSendFragmentCallback, 1 } }  ,
+{ "setServername"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__setServernameCallback, 1 } }  ,
+{ "setSession"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__setSessionCallback, 0 } }  ,
+{ "shutdown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__shutdownCallback, 1 } }  ,
+{ "timeout"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__timeoutCallback, 1 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__unrefCallback, 0 } }  ,
+{ "upgradeTLS"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__upgradeTLSCallback, 1 } }  ,
+{ "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__writeCallback, 3 } }
 };
 
+
+
 const ClassInfo JSTLSSocketPrototype::s_info = { "TLSSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTLSSocketPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsTLSSocketConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -25531,12 +27439,14 @@ JSC_DEFINE_CUSTOM_GETTER(jsTLSSocketConstructor, (JSGlobalObject * lexicalGlobal
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for TLSSocket"_s);
     return JSValue::encode(globalObject->JSTLSSocketConstructor());
-}
+}    
+    
+
 
 JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__alpnProtocolGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -25544,11 +27454,12 @@ JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__alpnProtocolGetterWrap, (JSGlobalOb
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__authorizedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -25556,37 +27467,42 @@ JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__authorizedGetterWrap, (JSGlobalObje
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__dataGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_data.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        TLSSocketPrototype__getData(thisObject->wrapped(), globalObject));
+        TLSSocketPrototype__getData(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_data.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void TLSSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
-    thisObject->m_data.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue TLSSocketPrototype__dataGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void TLSSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+      thisObject->m_data.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue TLSSocketPrototype__dataGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_data.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_SETTER(TLSSocketPrototype__dataSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
 {
@@ -25599,402 +27515,417 @@ JSC_DEFINE_CUSTOM_SETTER(TLSSocketPrototype__dataSetterWrap, (JSGlobalObject * l
     RELEASE_AND_RETURN(throwScope, result);
 }
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__endCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__endCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return TLSSocketPrototype__end(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__end(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__exportKeyingMaterialCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__exportKeyingMaterialCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__exportKeyingMaterial(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__exportKeyingMaterial(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__flushCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__flushCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__flush(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__flush(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getAuthorizationErrorCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getAuthorizationErrorCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getAuthorizationError(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getAuthorizationError(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getCertificateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getCertificateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getCertificate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getCertificate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getCipherCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getCipherCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getCipher(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getCipher(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getEphemeralKeyInfoCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getEphemeralKeyInfoCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getEphemeralKeyInfo(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getEphemeralKeyInfo(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getPeerCertificateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getPeerCertificateCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getPeerCertificate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getPeerCertificate(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getSessionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getSessionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getSession(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getSession(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getSharedSigalgsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getSharedSigalgsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getSharedSigalgs(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getSharedSigalgs(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getTLSFinishedMessageCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getTLSFinishedMessageCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getTLSFinishedMessage(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getTLSFinishedMessage(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getTLSPeerFinishedMessageCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getTLSPeerFinishedMessageCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getTLSPeerFinishedMessage(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getTLSPeerFinishedMessage(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getTLSTicketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getTLSTicketCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getTLSTicket(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__getTLSTicket(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getTLSVersionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__getTLSVersionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__getTLSVersion(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TLSSocketPrototype__getTLSVersion(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__listenerGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -26002,11 +27933,12 @@ JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__listenerGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__localPortGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -26014,11 +27946,12 @@ JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__localPortGetterWrap, (JSGlobalObjec
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__readyStateGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -26026,317 +27959,332 @@ JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__readyStateGetterWrap, (JSGlobalObje
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TLSSocketPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__remoteAddressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_remoteAddress.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        TLSSocketPrototype__getRemoteAddress(thisObject->wrapped(), globalObject));
+        TLSSocketPrototype__getRemoteAddress(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_remoteAddress.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void TLSSocketPrototype__remoteAddressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
-    thisObject->m_remoteAddress.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue TLSSocketPrototype__remoteAddressGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void TLSSocketPrototype__remoteAddressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+      thisObject->m_remoteAddress.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue TLSSocketPrototype__remoteAddressGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_remoteAddress.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__setMaxSendFragmentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__setMaxSendFragmentCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return TLSSocketPrototype__setMaxSendFragment(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__setMaxSendFragment(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__setServernameCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__setServernameCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__setServername(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__setServername(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__setSessionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__setSessionCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__setSession(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__setSession(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__shutdownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__shutdownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__shutdown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__shutdown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__timeoutCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__timeoutCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__timeout(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__timeout(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__upgradeTLSCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__upgradeTLSCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__upgradeTLS(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TLSSocketPrototype__upgradeTLS(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__writeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__writeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
 
-    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TLSSocket"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TLSSocketPrototype__write(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TLSSocketPrototype__write(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSTLSSocketPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -26346,10 +28294,9 @@ void JSTLSSocketPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* glob
 }
 
 extern "C" bool TLSSocket__hasPendingActivity(void* ptr);
-bool JSTLSSocket::hasPendingActivity(void* ctx)
-{
-    return TLSSocket__hasPendingActivity(ctx);
-}
+    bool JSTLSSocket::hasPendingActivity(void* ctx) {
+        return TLSSocket__hasPendingActivity(ctx);
+    }
 
 JSTLSSocket::~JSTLSSocket()
 {
@@ -26361,7 +28308,7 @@ void JSTLSSocket::destroy(JSCell* cell)
 {
     static_cast<JSTLSSocket*>(cell)->JSTLSSocket::~JSTLSSocket();
 }
-
+  
 const ClassInfo JSTLSSocket::s_info = { "TLSSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTLSSocket) };
 
 void JSTLSSocket::finishCreation(VM& vm)
@@ -26370,38 +28317,37 @@ void JSTLSSocket::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSTLSSocket* JSTLSSocket::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSTLSSocket* ptr = new (NotNull, JSC::allocateCell<JSTLSSocket>(vm)) JSTLSSocket(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* TLSSocket__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSTLSSocket* JSTLSSocket::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSTLSSocket* ptr = new (NotNull, JSC::allocateCell<JSTLSSocket>(vm)) JSTLSSocket(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSTLSSocket* object = JSC::jsDynamicCast<JSTLSSocket*>(cell);
+extern "C" void* TLSSocket__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSTLSSocket* object = JSC::jsDynamicCast<JSTLSSocket*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool TLSSocket__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSTLSSocket* object = JSC::jsDynamicCast<JSTLSSocket*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool TLSSocket__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSTLSSocket* object = JSC::jsDynamicCast<JSTLSSocket*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t TLSSocket__ptrOffset = JSTLSSocket::offsetOfWrapped();
 
 void JSTLSSocket::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -26414,18 +28360,19 @@ void JSTLSSocket::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSTLSSocket::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSTLSSocketPrototype::create(vm, globalObject, JSTLSSocketPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue TLSSocket__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSTLSSocketStructure();
-    JSTLSSocket* instance = JSTLSSocket::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue TLSSocket__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSTLSSocketStructure();
+  JSTLSSocket* instance = JSTLSSocket::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -26434,7 +28381,7 @@ void JSTLSSocket::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -26443,10 +28390,10 @@ DEFINE_VISIT_CHILDREN(JSTLSSocket);
 template<typename Visitor>
 void JSTLSSocket::visitAdditionalChildren(Visitor& visitor)
 {
-    JSTLSSocket* thisObject = this;
+  JSTLSSocket* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_data);
+    
+        visitor.append(thisObject->m_data);
     visitor.append(thisObject->m_remoteAddress);
     visitor.addOpaqueRoot(this->wrapped());
 }
@@ -26454,7 +28401,7 @@ void JSTLSSocket::visitAdditionalChildren(Visitor& visitor)
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSTLSSocket);
 
 template<typename Visitor>
-void JSTLSSocket::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSTLSSocket::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -26462,78 +28409,95 @@ void JSTLSSocket::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSTLSSocket);
-class JSTextChunkPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
+  class JSTextChunkPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSTextChunkPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSTextChunkPrototype* ptr = new (NotNull, JSC::allocateCell<JSTextChunkPrototype>(vm)) JSTextChunkPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTextChunkPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSTextChunkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
-    static JSTextChunkPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSTextChunkPrototype* ptr = new (NotNull, JSC::allocateCell<JSTextChunkPrototype>(vm)) JSTextChunkPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
+extern "C" void* TextChunkClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsTextChunkConstructor);
 
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTextChunkPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
 
-private:
-    JSTextChunkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
 
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
 
-extern "C" void* TextChunkClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsTextChunkConstructor);
 
 extern "C" void TextChunkClass__finalize(void*);
 
+
 extern "C" EncodedJSValue TextChunkPrototype__after(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TextChunkPrototype__afterCallback);
 
+
 extern "C" EncodedJSValue TextChunkPrototype__before(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TextChunkPrototype__beforeCallback);
 
+
 extern "C" JSC::EncodedJSValue TextChunkPrototype__lastInTextNode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TextChunkPrototype__lastInTextNodeGetterWrap);
 
+
 extern "C" EncodedJSValue TextChunkPrototype__remove(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TextChunkPrototype__removeCallback);
 
+
 extern "C" JSC::EncodedJSValue TextChunkPrototype__removed(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TextChunkPrototype__removedGetterWrap);
 
+
 extern "C" EncodedJSValue TextChunkPrototype__replace(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TextChunkPrototype__replaceCallback);
 
+
 extern "C" JSC::EncodedJSValue TextChunkPrototype__getText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TextChunkPrototype__textGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTextChunkPrototype, JSTextChunkPrototype::Base);
 
-static const HashTableValue JSTextChunkPrototypeTableValues[] = {
-    { "after"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TextChunkPrototype__afterCallback, 1 } },
-    { "before"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TextChunkPrototype__beforeCallback, 1 } },
-    { "lastInTextNode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextChunkPrototype__lastInTextNodeGetterWrap, 0 } },
-    { "remove"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TextChunkPrototype__removeCallback, 0 } },
-    { "removed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextChunkPrototype__removedGetterWrap, 0 } },
-    { "replace"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TextChunkPrototype__replaceCallback, 1 } },
-    { "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextChunkPrototype__textGetterWrap, 0 } }
+
+  static const HashTableValue JSTextChunkPrototypeTableValues[] = {
+{ "after"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TextChunkPrototype__afterCallback, 1 } }  ,
+{ "before"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TextChunkPrototype__beforeCallback, 1 } }  ,
+{ "lastInTextNode"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextChunkPrototype__lastInTextNodeGetterWrap, 0 } }  ,
+{ "remove"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TextChunkPrototype__removeCallback, 0 } }  ,
+{ "removed"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextChunkPrototype__removedGetterWrap, 0 } }  ,
+{ "replace"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TextChunkPrototype__replaceCallback, 1 } }  ,
+{ "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextChunkPrototype__textGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSTextChunkPrototype::s_info = { "TextChunk"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTextChunkPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsTextChunkConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -26544,127 +28508,136 @@ JSC_DEFINE_CUSTOM_GETTER(jsTextChunkConstructor, (JSGlobalObject * lexicalGlobal
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for TextChunk"_s);
     return JSValue::encode(globalObject->JSTextChunkConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(TextChunkPrototype__afterCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSTextChunk* thisObject = jsDynamicCast<JSTextChunk*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(TextChunkPrototype__afterCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextChunk"_s);
-        return JSValue::encode({});
-    }
+        JSTextChunk* thisObject = jsDynamicCast<JSTextChunk*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextChunk"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return TextChunkPrototype__after(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TextChunkPrototype__after(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TextChunkPrototype__beforeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TextChunkPrototype__beforeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTextChunk* thisObject = jsDynamicCast<JSTextChunk*>(callFrame->thisValue());
 
-    JSTextChunk* thisObject = jsDynamicCast<JSTextChunk*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextChunk"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextChunk"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TextChunkPrototype__before(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TextChunkPrototype__before(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 JSC_DEFINE_CUSTOM_GETTER(TextChunkPrototype__lastInTextNodeGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTextChunk* thisObject = jsCast<JSTextChunk*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_lastInTextNode.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        TextChunkPrototype__lastInTextNode(thisObject->wrapped(), globalObject));
+        TextChunkPrototype__lastInTextNode(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_lastInTextNode.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void TextChunkPrototype__lastInTextNodeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSTextChunk*>(JSValue::decode(thisValue));
-    thisObject->m_lastInTextNode.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue TextChunkPrototype__lastInTextNodeGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void TextChunkPrototype__lastInTextNodeSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSTextChunk*>(JSValue::decode(thisValue));
+      thisObject->m_lastInTextNode.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue TextChunkPrototype__lastInTextNodeGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSTextChunk*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_lastInTextNode.get());
-}
+  }
+  
+  
 
-JSC_DEFINE_HOST_FUNCTION(TextChunkPrototype__removeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(TextChunkPrototype__removeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSTextChunk* thisObject = jsDynamicCast<JSTextChunk*>(callFrame->thisValue());
+        JSTextChunk* thisObject = jsDynamicCast<JSTextChunk*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextChunk"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextChunk"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return TextChunkPrototype__remove(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return TextChunkPrototype__remove(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(TextChunkPrototype__removedGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTextChunk* thisObject = jsCast<JSTextChunk*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -26672,39 +28645,41 @@ JSC_DEFINE_CUSTOM_GETTER(TextChunkPrototype__removedGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
-JSC_DEFINE_HOST_FUNCTION(TextChunkPrototype__replaceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+    JSC_DEFINE_HOST_FUNCTION(TextChunkPrototype__replaceCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    JSTextChunk* thisObject = jsDynamicCast<JSTextChunk*>(callFrame->thisValue());
+        JSTextChunk* thisObject = jsDynamicCast<JSTextChunk*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextChunk"_s);
-        return JSValue::encode({});
-    }
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextChunk"_s);
+            return JSValue::encode({});
+        }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-    return TextChunkPrototype__replace(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        return TextChunkPrototype__replace(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(TextChunkPrototype__textGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTextChunk* thisObject = jsCast<JSTextChunk*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -26712,6 +28687,7 @@ JSC_DEFINE_CUSTOM_GETTER(TextChunkPrototype__textGetterWrap, (JSGlobalObject * l
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 void JSTextChunkPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -26730,7 +28706,7 @@ void JSTextChunk::destroy(JSCell* cell)
 {
     static_cast<JSTextChunk*>(cell)->JSTextChunk::~JSTextChunk();
 }
-
+  
 const ClassInfo JSTextChunk::s_info = { "TextChunk"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTextChunk) };
 
 void JSTextChunk::finishCreation(VM& vm)
@@ -26739,38 +28715,37 @@ void JSTextChunk::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSTextChunk* JSTextChunk::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSTextChunk* ptr = new (NotNull, JSC::allocateCell<JSTextChunk>(vm)) JSTextChunk(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* TextChunk__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSTextChunk* JSTextChunk::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSTextChunk* ptr = new (NotNull, JSC::allocateCell<JSTextChunk>(vm)) JSTextChunk(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSTextChunk* object = JSC::jsDynamicCast<JSTextChunk*>(cell);
+extern "C" void* TextChunk__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSTextChunk* object = JSC::jsDynamicCast<JSTextChunk*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool TextChunk__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSTextChunk* object = JSC::jsDynamicCast<JSTextChunk*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool TextChunk__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSTextChunk* object = JSC::jsDynamicCast<JSTextChunk*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t TextChunk__ptrOffset = JSTextChunk::offsetOfWrapped();
 
 void JSTextChunk::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -26783,18 +28758,19 @@ void JSTextChunk::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSTextChunk::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSTextChunkPrototype::create(vm, globalObject, JSTextChunkPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue TextChunk__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSTextChunkStructure();
-    JSTextChunk* instance = JSTextChunk::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue TextChunk__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSTextChunkStructure();
+  JSTextChunk* instance = JSTextChunk::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -26803,7 +28779,7 @@ void JSTextChunk::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSTextChunk* thisObject = jsCast<JSTextChunk*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -26812,16 +28788,17 @@ DEFINE_VISIT_CHILDREN(JSTextChunk);
 template<typename Visitor>
 void JSTextChunk::visitAdditionalChildren(Visitor& visitor)
 {
-    JSTextChunk* thisObject = this;
+  JSTextChunk* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_lastInTextNode);
+    
+        visitor.append(thisObject->m_lastInTextNode);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSTextChunk);
 
 template<typename Visitor>
-void JSTextChunk::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSTextChunk::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSTextChunk* thisObject = jsCast<JSTextChunk*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -26829,90 +28806,97 @@ void JSTextChunk::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSTextChunk);
-class JSTextDecoderPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSTextDecoderPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSTextDecoderPrototype* ptr = new (NotNull, JSC::allocateCell<JSTextDecoderPrototype>(vm)) JSTextDecoderPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTextDecoderPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSTextDecoderPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSTextDecoderPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSTextDecoderPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSTextDecoderPrototype* ptr = new (NotNull, JSC::allocateCell<JSTextDecoderPrototype>(vm)) JSTextDecoderPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTextDecoderPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSTextDecoderPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSTextDecoderConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSTextDecoderConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTextDecoderPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSTextDecoderConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTextDecoderPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTextDecoderConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTextDecoderConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTextDecoderConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTextDecoderConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTextDecoderConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSTextDecoderPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSTextDecoderConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSTextDecoderPrototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
-
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSTextDecoderConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTextDecoderConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTextDecoderConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTextDecoderConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTextDecoderConstructor = std::forward<decltype(space)>(space); });
-    }
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSTextDecoderPrototype* prototype);
+extern "C" void* TextDecoderClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsTextDecoderConstructor);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSTextDecoderConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSTextDecoderPrototype* prototype);
-};
 
-extern "C" void* TextDecoderClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsTextDecoderConstructor);
 
 extern "C" void TextDecoderClass__finalize(void*);
 
+
 extern "C" EncodedJSValue TextDecoderPrototype__decode(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TextDecoderPrototype__decodeCallback);
 
+
 extern "C" JSC_DECLARE_JIT_OPERATION_WITHOUT_WTF_INTERNAL(TextDecoderPrototype__decodeWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSUint8Array* arg0));
-extern "C" EncodedJSValue TextDecoderPrototype__decodeWithoutTypeChecks(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSUint8Array* arg0);
+  extern "C" EncodedJSValue TextDecoderPrototype__decodeWithoutTypeChecks(void* ptr, JSC::JSGlobalObject * lexicalGlobalObject, JSC::JSUint8Array* arg0);
 
-static const JSC::DOMJIT::Signature DOMJITSignatureForTextDecoderPrototype__decode(TextDecoderPrototype__decodeWithoutTypeChecksWrapper,
-    JSTextDecoder::info(),
-    JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()),
-    JSC::SpecString, JSC::SpecUint8Array);
+  static const JSC::DOMJIT::Signature DOMJITSignatureForTextDecoderPrototype__decode(TextDecoderPrototype__decodeWithoutTypeChecksWrapper, 
+  JSTextDecoder::info(), 
+  JSC::DOMJIT::Effect::forReadWrite(JSC::DOMJIT::HeapRange::top(), JSC::DOMJIT::HeapRange::top()), 
+  JSC::SpecString, JSC::SpecUint8Array);
 
 JSC_DEFINE_JIT_OPERATION(TextDecoderPrototype__decodeWithoutTypeChecksWrapper, EncodedJSValue, (JSC::JSGlobalObject * lexicalGlobalObject, void* thisValue, JSC::JSUint8Array* arg0))
 {
@@ -26927,23 +28911,31 @@ JSC_DEFINE_JIT_OPERATION(TextDecoderPrototype__decodeWithoutTypeChecksWrapper, E
 extern "C" JSC::EncodedJSValue TextDecoderPrototype__getEncoding(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TextDecoderPrototype__encodingGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TextDecoderPrototype__getFatal(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TextDecoderPrototype__fatalGetterWrap);
 
+
 extern "C" JSC::EncodedJSValue TextDecoderPrototype__getIgnoreBOM(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(TextDecoderPrototype__ignoreBOMGetterWrap);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTextDecoderPrototype, JSTextDecoderPrototype::Base);
 
-static const HashTableValue JSTextDecoderPrototypeTableValues[] = {
-    { "decode"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, TextDecoderPrototype__decodeCallback, &DOMJITSignatureForTextDecoderPrototype__decode } },
-    { "encoding"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextDecoderPrototype__encodingGetterWrap, 0 } },
-    { "fatal"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextDecoderPrototype__fatalGetterWrap, 0 } },
-    { "ignoreBOM"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextDecoderPrototype__ignoreBOMGetterWrap, 0 } }
+
+  static const HashTableValue JSTextDecoderPrototypeTableValues[] = {
+{ "decode"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | JSC::PropertyAttribute::DOMJITFunction | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::DOMJITFunctionType, TextDecoderPrototype__decodeCallback, &DOMJITSignatureForTextDecoderPrototype__decode } }  ,
+{ "encoding"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextDecoderPrototype__encodingGetterWrap, 0 } }  ,
+{ "fatal"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextDecoderPrototype__fatalGetterWrap, 0 } }  ,
+{ "ignoreBOM"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, TextDecoderPrototype__ignoreBOMGetterWrap, 0 } }
 };
 
+
+
 const ClassInfo JSTextDecoderPrototype::s_info = { "TextDecoder"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTextDecoderPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsTextDecoderConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -26954,71 +28946,78 @@ JSC_DEFINE_CUSTOM_GETTER(jsTextDecoderConstructor, (JSGlobalObject * lexicalGlob
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for TextDecoder"_s);
     return JSValue::encode(globalObject->JSTextDecoderConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(TextDecoderPrototype__decodeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSTextDecoder* thisObject = jsDynamicCast<JSTextDecoder*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(TextDecoderPrototype__decodeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextDecoder"_s);
-        return JSValue::encode({});
-    }
+        JSTextDecoder* thisObject = jsDynamicCast<JSTextDecoder*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof TextDecoder"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    return TextDecoderPrototype__decode(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return TextDecoderPrototype__decode(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
 
 JSC_DEFINE_CUSTOM_GETTER(TextDecoderPrototype__encodingGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTextDecoder* thisObject = jsCast<JSTextDecoder*>(JSValue::decode(thisValue));
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
-
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
     if (JSValue cachedValue = thisObject->m_encoding.get())
         return JSValue::encode(cachedValue);
-
+    
     JSC::JSValue result = JSC::JSValue::decode(
-        TextDecoderPrototype__getEncoding(thisObject->wrapped(), globalObject));
+        TextDecoderPrototype__getEncoding(thisObject->wrapped(), globalObject)
+    );
     RETURN_IF_EXCEPTION(throwScope, {});
     thisObject->m_encoding.set(vm, thisObject, result);
     RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
 }
 
-extern "C" void TextDecoderPrototype__encodingSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSTextDecoder*>(JSValue::decode(thisValue));
-    thisObject->m_encoding.set(vm, thisObject, JSValue::decode(value));
-}
 
-extern "C" EncodedJSValue TextDecoderPrototype__encodingGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  extern "C" void TextDecoderPrototype__encodingSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSTextDecoder*>(JSValue::decode(thisValue));
+      thisObject->m_encoding.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue TextDecoderPrototype__encodingGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSTextDecoder*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_encoding.get());
-}
+  }
+  
+  
 
 JSC_DEFINE_CUSTOM_GETTER(TextDecoderPrototype__fatalGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTextDecoder* thisObject = jsCast<JSTextDecoder*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -27026,11 +29025,12 @@ JSC_DEFINE_CUSTOM_GETTER(TextDecoderPrototype__fatalGetterWrap, (JSGlobalObject
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 JSC_DEFINE_CUSTOM_GETTER(TextDecoderPrototype__ignoreBOMGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
 {
     auto& vm = lexicalGlobalObject->vm();
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     JSTextDecoder* thisObject = jsCast<JSTextDecoder*>(JSValue::decode(thisValue));
     JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
@@ -27038,6 +29038,7 @@ JSC_DEFINE_CUSTOM_GETTER(TextDecoderPrototype__ignoreBOMGetterWrap, (JSGlobalObj
     RETURN_IF_EXCEPTION(throwScope, {});
     RELEASE_AND_RETURN(throwScope, result);
 }
+        
 
 void JSTextDecoderPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -27049,64 +29050,67 @@ void JSTextDecoderPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* gl
 void JSTextDecoderConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSTextDecoderPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "TextDecoder"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSTextDecoderConstructor::JSTextDecoderConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSTextDecoderConstructor::JSTextDecoderConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSTextDecoderConstructor* JSTextDecoderConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTextDecoderPrototype* prototype)
-{
+  }
+
+JSTextDecoderConstructor* JSTextDecoderConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTextDecoderPrototype* prototype) {
     JSTextDecoderConstructor* ptr = new (NotNull, JSC::allocateCell<JSTextDecoderConstructor>(vm)) JSTextDecoderConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSTextDecoderConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSTextDecoderConstructor();
     Structure* structure = globalObject->JSTextDecoderStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSTextDecoderStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSTextDecoderStructure()
+      );
     }
 
     void* ptr = TextDecoderClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSTextDecoder* instance = JSTextDecoder::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSTextDecoderConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSTextDecoderPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSTextDecoderConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTextDecoderConstructor) };
 
-extern "C" EncodedJSValue TextDecoder__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue TextDecoder__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSTextDecoderConstructor());
-}
+  }
 
 JSTextDecoder::~JSTextDecoder()
 {
@@ -27118,7 +29122,7 @@ void JSTextDecoder::destroy(JSCell* cell)
 {
     static_cast<JSTextDecoder*>(cell)->JSTextDecoder::~JSTextDecoder();
 }
-
+  
 const ClassInfo JSTextDecoder::s_info = { "TextDecoder"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTextDecoder) };
 
 void JSTextDecoder::finishCreation(VM& vm)
@@ -27127,38 +29131,37 @@ void JSTextDecoder::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSTextDecoder* JSTextDecoder::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSTextDecoder* ptr = new (NotNull, JSC::allocateCell<JSTextDecoder>(vm)) JSTextDecoder(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* TextDecoder__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSTextDecoder* JSTextDecoder::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSTextDecoder* ptr = new (NotNull, JSC::allocateCell<JSTextDecoder>(vm)) JSTextDecoder(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSTextDecoder* object = JSC::jsDynamicCast<JSTextDecoder*>(cell);
+extern "C" void* TextDecoder__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSTextDecoder* object = JSC::jsDynamicCast<JSTextDecoder*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool TextDecoder__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSTextDecoder* object = JSC::jsDynamicCast<JSTextDecoder*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool TextDecoder__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSTextDecoder* object = JSC::jsDynamicCast<JSTextDecoder*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t TextDecoder__ptrOffset = JSTextDecoder::offsetOfWrapped();
 
 void JSTextDecoder::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -27173,7 +29176,7 @@ void JSTextDecoder::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSTextDecoder::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSTextDecoderConstructor::create(vm, globalObject, WebCore::JSTextDecoderConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSTextDecoderPrototype*>(prototype));
+  return WebCore::JSTextDecoderConstructor::create(vm, globalObject, WebCore::JSTextDecoderConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSTextDecoderPrototype*>(prototype));
 }
 
 JSObject* JSTextDecoder::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -27181,13 +29184,12 @@ JSObject* JSTextDecoder::createPrototype(VM& vm, JSDOMGlobalObject* globalObject
     return JSTextDecoderPrototype::create(vm, globalObject, JSTextDecoderPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue TextDecoder__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSTextDecoderStructure();
-    JSTextDecoder* instance = JSTextDecoder::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue TextDecoder__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSTextDecoderStructure();
+  JSTextDecoder* instance = JSTextDecoder::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -27196,7 +29198,7 @@ void JSTextDecoder::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSTextDecoder* thisObject = jsCast<JSTextDecoder*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -27205,16 +29207,17 @@ DEFINE_VISIT_CHILDREN(JSTextDecoder);
 template<typename Visitor>
 void JSTextDecoder::visitAdditionalChildren(Visitor& visitor)
 {
-    JSTextDecoder* thisObject = this;
+  JSTextDecoder* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-
-    visitor.append(thisObject->m_encoding);
+    
+        visitor.append(thisObject->m_encoding);
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSTextDecoder);
 
 template<typename Visitor>
-void JSTextDecoder::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSTextDecoder::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSTextDecoder* thisObject = jsCast<JSTextDecoder*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -27222,231 +29225,252 @@ void JSTextDecoder::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSTextDecoder);
-class JSTimeoutPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSTimeoutPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSTimeoutPrototype* ptr = new (NotNull, JSC::allocateCell<JSTimeoutPrototype>(vm)) JSTimeoutPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTimeoutPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSTimeoutPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSTimeoutPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSTimeoutPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSTimeoutPrototype* ptr = new (NotNull, JSC::allocateCell<JSTimeoutPrototype>(vm)) JSTimeoutPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTimeoutPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSTimeoutPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 extern "C" void TimeoutClass__finalize(void*);
 
+
 extern "C" EncodedJSValue TimeoutPrototype__toPrimitive(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TimeoutPrototype__toPrimitiveCallback);
 
+
 extern "C" EncodedJSValue TimeoutPrototype__hasRef(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TimeoutPrototype__hasRefCallback);
 
+
 extern "C" EncodedJSValue TimeoutPrototype__doRef(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TimeoutPrototype__refCallback);
 
+
 extern "C" EncodedJSValue TimeoutPrototype__doRefresh(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TimeoutPrototype__refreshCallback);
 
+
 extern "C" EncodedJSValue TimeoutPrototype__doUnref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TimeoutPrototype__unrefCallback);
 
-STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTimeoutPrototype, JSTimeoutPrototype::Base);
 
-static const HashTableValue JSTimeoutPrototypeTableValues[] = {
-    { "hasRef"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TimeoutPrototype__hasRefCallback, 0 } },
-    { "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TimeoutPrototype__refCallback, 0 } },
-    { "refresh"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TimeoutPrototype__refreshCallback, 0 } },
-    { "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TimeoutPrototype__unrefCallback, 0 } }
-};
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTimeoutPrototype, JSTimeoutPrototype::Base);
 
-const ClassInfo JSTimeoutPrototype::s_info = { "Timeout"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTimeoutPrototype) };
 
-JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__toPrimitiveCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+  static const HashTableValue JSTimeoutPrototypeTableValues[] = {
+{ "hasRef"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TimeoutPrototype__hasRefCallback, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TimeoutPrototype__refCallback, 0 } }  ,
+{ "refresh"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TimeoutPrototype__refreshCallback, 0 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TimeoutPrototype__unrefCallback, 0 } }
+};
 
-    JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
-        return JSValue::encode({});
-    }
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+const ClassInfo JSTimeoutPrototype::s_info = { "Timeout"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTimeoutPrototype) };
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
-    }
-#endif
 
-    return TimeoutPrototype__toPrimitive(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__toPrimitiveCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__hasRefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
 
-    JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TimeoutPrototype__toPrimitive(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TimeoutPrototype__hasRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__hasRefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
 
-    JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TimeoutPrototype__hasRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TimeoutPrototype__doRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__refreshCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
 
-    JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TimeoutPrototype__doRef(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TimeoutPrototype__doRefresh(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__refreshCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
 
-    JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TimeoutPrototype__doRefresh(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TimeoutPrototype__doUnref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
-
-extern "C" void TimeoutPrototype__argumentsSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSTimeout*>(JSValue::decode(thisValue));
-    thisObject->m_arguments.set(vm, thisObject, JSValue::decode(value));
-}
+    
 
-extern "C" EncodedJSValue TimeoutPrototype__argumentsGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+    JSC_DEFINE_HOST_FUNCTION(TimeoutPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
+
+        JSTimeout* thisObject = jsDynamicCast<JSTimeout*>(callFrame->thisValue());
+
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Timeout"_s);
+            return JSValue::encode({});
+        }
+
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return TimeoutPrototype__doUnref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+    }
+    
+
+
+  extern "C" void TimeoutPrototype__argumentsSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSTimeout*>(JSValue::decode(thisValue));
+      thisObject->m_arguments.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue TimeoutPrototype__argumentsGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSTimeout*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_arguments.get());
-}
-
-extern "C" void TimeoutPrototype__callbackSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
-{
-    auto& vm = globalObject->vm();
-    auto* thisObject = jsCast<JSTimeout*>(JSValue::decode(thisValue));
-    thisObject->m_callback.set(vm, thisObject, JSValue::decode(value));
-}
-
-extern "C" EncodedJSValue TimeoutPrototype__callbackGetCachedValue(JSC::EncodedJSValue thisValue)
-{
+  }
+  
+  
+
+
+  extern "C" void TimeoutPrototype__callbackSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+  {
+      auto& vm = globalObject->vm();
+      auto* thisObject = jsCast<JSTimeout*>(JSValue::decode(thisValue));
+      thisObject->m_callback.set(vm, thisObject, JSValue::decode(value));
+  }
+  
+  extern "C" EncodedJSValue TimeoutPrototype__callbackGetCachedValue(JSC::EncodedJSValue thisValue)
+  {
     auto* thisObject = jsCast<JSTimeout*>(JSValue::decode(thisValue));
     return JSValue::encode(thisObject->m_callback.get());
-}
+  }
+  
+  
 
 void JSTimeoutPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -27466,7 +29490,7 @@ void JSTimeout::destroy(JSCell* cell)
 {
     static_cast<JSTimeout*>(cell)->JSTimeout::~JSTimeout();
 }
-
+  
 const ClassInfo JSTimeout::s_info = { "Timeout"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTimeout) };
 
 void JSTimeout::finishCreation(VM& vm)
@@ -27475,38 +29499,37 @@ void JSTimeout::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSTimeout* JSTimeout::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSTimeout* ptr = new (NotNull, JSC::allocateCell<JSTimeout>(vm)) JSTimeout(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Timeout__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSTimeout* JSTimeout::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSTimeout* ptr = new (NotNull, JSC::allocateCell<JSTimeout>(vm)) JSTimeout(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSTimeout* object = JSC::jsDynamicCast<JSTimeout*>(cell);
+extern "C" void* Timeout__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSTimeout* object = JSC::jsDynamicCast<JSTimeout*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Timeout__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSTimeout* object = JSC::jsDynamicCast<JSTimeout*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Timeout__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSTimeout* object = JSC::jsDynamicCast<JSTimeout*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Timeout__ptrOffset = JSTimeout::offsetOfWrapped();
 
 void JSTimeout::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -27519,18 +29542,19 @@ void JSTimeout::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+
+
 JSObject* JSTimeout::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
     return JSTimeoutPrototype::create(vm, globalObject, JSTimeoutPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Timeout__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSTimeoutStructure();
-    JSTimeout* instance = JSTimeout::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
+extern "C" EncodedJSValue Timeout__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSTimeoutStructure();
+  JSTimeout* instance = JSTimeout::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
 }
 
 template<typename Visitor>
@@ -27539,7 +29563,7 @@ void JSTimeout::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     JSTimeout* thisObject = jsCast<JSTimeout*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     Base::visitChildren(thisObject, visitor);
-
+    
     thisObject->visitAdditionalChildren<Visitor>(visitor);
 }
 
@@ -27548,16 +29572,18 @@ DEFINE_VISIT_CHILDREN(JSTimeout);
 template<typename Visitor>
 void JSTimeout::visitAdditionalChildren(Visitor& visitor)
 {
-    JSTimeout* thisObject = this;
+  JSTimeout* thisObject = this;
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
     visitor.append(thisObject->m_arguments);
-    visitor.append(thisObject->m_callback);
+visitor.append(thisObject->m_callback);
+    
+    
 }
 
 DEFINE_VISIT_ADDITIONAL_CHILDREN(JSTimeout);
 
 template<typename Visitor>
-void JSTimeout::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
+void JSTimeout::visitOutputConstraintsImpl(JSCell *cell, Visitor& visitor)
 {
     JSTimeout* thisObject = jsCast<JSTimeout*>(cell);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
@@ -27565,103 +29591,118 @@ void JSTimeout::visitOutputConstraintsImpl(JSCell* cell, Visitor& visitor)
 }
 
 DEFINE_VISIT_OUTPUT_CONSTRAINTS(JSTimeout);
-class JSTranspilerPrototype final : public JSC::JSNonFinalObject {
-public:
-    using Base = JSC::JSNonFinalObject;
-
-    static JSTranspilerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
-    {
-        JSTranspilerPrototype* ptr = new (NotNull, JSC::allocateCell<JSTranspilerPrototype>(vm)) JSTranspilerPrototype(vm, globalObject, structure);
-        ptr->finishCreation(vm, globalObject);
-        return ptr;
-    }
-
-    DECLARE_INFO;
-    template<typename CellType, JSC::SubspaceAccess>
-    static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTranspilerPrototype, Base);
-        return &vm.plainObjectSpace();
-    }
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
-    }
-
-private:
-    JSTranspilerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
-        : Base(vm, structure)
-    {
-    }
-
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
-};
+  class JSTranspilerPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSTranspilerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSTranspilerPrototype* ptr = new (NotNull, JSC::allocateCell<JSTranspilerPrototype>(vm)) JSTranspilerPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTranspilerPrototype, Base);
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSTranspilerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
 
 class JSTranspilerConstructor final : public JSC::InternalFunction {
-public:
-    using Base = JSC::InternalFunction;
-    static JSTranspilerConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTranspilerPrototype* prototype);
+    public:
+        using Base = JSC::InternalFunction;
+        static JSTranspilerConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTranspilerPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTranspilerConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTranspilerConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTranspilerConstructor = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTranspilerConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTranspilerConstructor = std::forward<decltype(space)>(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSTranspilerPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+
+        DECLARE_EXPORT_INFO;
+    private:
+        JSTranspilerConstructor(JSC::VM& vm, JSC::Structure* structure);
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSTranspilerPrototype* prototype);
+    };
 
-    static constexpr unsigned StructureFlags = Base::StructureFlags;
-    static constexpr bool needsDestruction = false;
-
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
-    }
 
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSTranspilerConstructor, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTranspilerConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTranspilerConstructor = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTranspilerConstructor.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTranspilerConstructor = std::forward<decltype(space)>(space); });
-    }
+extern "C" void* TranspilerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsTranspilerConstructor);
 
-    void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSTranspilerPrototype* prototype);
 
-    // Must be defined for each specialization class.
-    static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 
-    DECLARE_EXPORT_INFO;
 
-private:
-    JSTranspilerConstructor(JSC::VM& vm, JSC::Structure* structure);
-    void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSTranspilerPrototype* prototype);
-};
-
-extern "C" void* TranspilerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
-JSC_DECLARE_CUSTOM_GETTER(jsTranspilerConstructor);
 
 extern "C" void TranspilerClass__finalize(void*);
 
+
 extern "C" EncodedJSValue TranspilerPrototype__scan(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TranspilerPrototype__scanCallback);
 
+
 extern "C" EncodedJSValue TranspilerPrototype__scanImports(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TranspilerPrototype__scanImportsCallback);
 
+
 extern "C" EncodedJSValue TranspilerPrototype__transform(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TranspilerPrototype__transformCallback);
 
+
 extern "C" EncodedJSValue TranspilerPrototype__transformSync(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(TranspilerPrototype__transformSyncCallback);
 
+
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTranspilerPrototype, JSTranspilerPrototype::Base);
 
-static const HashTableValue JSTranspilerPrototypeTableValues[] = {
-    { "scan"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TranspilerPrototype__scanCallback, 2 } },
-    { "scanImports"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TranspilerPrototype__scanImportsCallback, 2 } },
-    { "transform"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TranspilerPrototype__transformCallback, 2 } },
-    { "transformSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TranspilerPrototype__transformSyncCallback, 2 } }
+
+  static const HashTableValue JSTranspilerPrototypeTableValues[] = {
+{ "scan"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TranspilerPrototype__scanCallback, 2 } }  ,
+{ "scanImports"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TranspilerPrototype__scanImportsCallback, 2 } }  ,
+{ "transform"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TranspilerPrototype__transformCallback, 2 } }  ,
+{ "transformSync"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, TranspilerPrototype__transformSyncCallback, 2 } }
 };
 
+
+
 const ClassInfo JSTranspilerPrototype::s_info = { "Transpiler"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTranspilerPrototype) };
 
+
+
 JSC_DEFINE_CUSTOM_GETTER(jsTranspilerConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
 {
     VM& vm = JSC::getVM(lexicalGlobalObject);
@@ -27672,119 +29713,125 @@ JSC_DEFINE_CUSTOM_GETTER(jsTranspilerConstructor, (JSGlobalObject * lexicalGloba
     if (UNLIKELY(!prototype))
         return throwVMTypeError(lexicalGlobalObject, throwScope, "Cannot get constructor for Transpiler"_s);
     return JSValue::encode(globalObject->JSTranspilerConstructor());
-}
+}    
+    
 
-JSC_DEFINE_HOST_FUNCTION(TranspilerPrototype__scanCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
 
-    JSTranspiler* thisObject = jsDynamicCast<JSTranspiler*>(callFrame->thisValue());
+    JSC_DEFINE_HOST_FUNCTION(TranspilerPrototype__scanCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Transpiler"_s);
-        return JSValue::encode({});
-    }
+        JSTranspiler* thisObject = jsDynamicCast<JSTranspiler*>(callFrame->thisValue());
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Transpiler"_s);
+            return JSValue::encode({});
+        }
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
+
+        return TranspilerPrototype__scan(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TranspilerPrototype__scan(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TranspilerPrototype__scanImportsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TranspilerPrototype__scanImportsCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTranspiler* thisObject = jsDynamicCast<JSTranspiler*>(callFrame->thisValue());
 
-    JSTranspiler* thisObject = jsDynamicCast<JSTranspiler*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Transpiler"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Transpiler"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TranspilerPrototype__scanImports(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TranspilerPrototype__scanImports(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TranspilerPrototype__transformCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TranspilerPrototype__transformCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTranspiler* thisObject = jsDynamicCast<JSTranspiler*>(callFrame->thisValue());
 
-    JSTranspiler* thisObject = jsDynamicCast<JSTranspiler*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Transpiler"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Transpiler"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TranspilerPrototype__transform(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
+    
 
-    return TranspilerPrototype__transform(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    JSC_DEFINE_HOST_FUNCTION(TranspilerPrototype__transformSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+    {
+        auto& vm = lexicalGlobalObject->vm();
 
-JSC_DEFINE_HOST_FUNCTION(TranspilerPrototype__transformSyncCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
-{
-    auto& vm = lexicalGlobalObject->vm();
+        JSTranspiler* thisObject = jsDynamicCast<JSTranspiler*>(callFrame->thisValue());
 
-    JSTranspiler* thisObject = jsDynamicCast<JSTranspiler*>(callFrame->thisValue());
+        if (UNLIKELY(!thisObject)) {
+            auto throwScope = DECLARE_THROW_SCOPE(vm);
+            throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Transpiler"_s);
+            return JSValue::encode({});
+        }
 
-    if (UNLIKELY(!thisObject)) {
-        auto throwScope = DECLARE_THROW_SCOPE(vm);
-        throwVMTypeError(lexicalGlobalObject, throwScope, "Expected 'this' to be instanceof Transpiler"_s);
-        return JSValue::encode({});
-    }
+        JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
 
-    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+        #ifdef BUN_DEBUG
+          /** View the file name of the JS file that called this function
+           * from a debugger */ 
+          SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
+          const char* fileName = sourceOrigin.string().utf8().data();
+          static const char* lastFileName = nullptr;
+          if (lastFileName != fileName) {
+            lastFileName = fileName;
+          }
+        #endif
 
-#ifdef BUN_DEBUG
-    /** View the file name of the JS file that called this function
-     * from a debugger */
-    SourceOrigin sourceOrigin = callFrame->callerSourceOrigin(vm);
-    const char* fileName = sourceOrigin.string().utf8().data();
-    static const char* lastFileName = nullptr;
-    if (lastFileName != fileName) {
-        lastFileName = fileName;
+        return TranspilerPrototype__transformSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
     }
-#endif
-
-    return TranspilerPrototype__transformSync(thisObject->wrapped(), lexicalGlobalObject, callFrame);
-}
+    
 
 void JSTranspilerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
@@ -27796,64 +29843,67 @@ void JSTranspilerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* glo
 void JSTranspilerConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSTranspilerPrototype* prototype)
 {
     Base::finishCreation(vm, 0, "Transpiler"_s, PropertyAdditionMode::WithoutStructureTransition);
-
+    
     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
     ASSERT(inherits(info()));
 }
 
-JSTranspilerConstructor::JSTranspilerConstructor(JSC::VM& vm, JSC::Structure* structure)
-    : Base(vm, structure, construct, construct)
-{
-}
+JSTranspilerConstructor::JSTranspilerConstructor(JSC::VM& vm, JSC::Structure* structure) : Base(vm, structure, construct, construct) {
 
-JSTranspilerConstructor* JSTranspilerConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTranspilerPrototype* prototype)
-{
+  }
+
+JSTranspilerConstructor* JSTranspilerConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTranspilerPrototype* prototype) {
     JSTranspilerConstructor* ptr = new (NotNull, JSC::allocateCell<JSTranspilerConstructor>(vm)) JSTranspilerConstructor(vm, structure);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
+
 JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSTranspilerConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
-    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
-    JSC::VM& vm = globalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
     JSObject* newTarget = asObject(callFrame->newTarget());
     auto* constructor = globalObject->JSTranspilerConstructor();
     Structure* structure = globalObject->JSTranspilerStructure();
     if (constructor != newTarget) {
-        auto scope = DECLARE_THROW_SCOPE(vm);
+      auto scope = DECLARE_THROW_SCOPE(vm);
 
-        auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
-            // ShadowRealm functions belong to a different global object.
-            getFunctionRealm(globalObject, newTarget));
-        RETURN_IF_EXCEPTION(scope, {});
-        structure = InternalFunction::createSubclassStructure(
-            globalObject,
-            newTarget,
-            functionGlobalObject->JSTranspilerStructure());
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSTranspilerStructure()
+      );
     }
 
     void* ptr = TranspilerClass__construct(globalObject, callFrame);
 
     if (UNLIKELY(!ptr)) {
-        return JSValue::encode(JSC::jsUndefined());
+      return JSValue::encode(JSC::jsUndefined());
     }
 
     JSTranspiler* instance = JSTranspiler::create(vm, globalObject, structure, ptr);
+  
 
     return JSValue::encode(instance);
 }
 
 void JSTranspilerConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSTranspilerPrototype* prototype)
 {
+
 }
 
 const ClassInfo JSTranspilerConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTranspilerConstructor) };
 
-extern "C" EncodedJSValue Transpiler__getConstructor(Zig::GlobalObject* globalObject)
-{
+
+  extern "C" EncodedJSValue Transpiler__getConstructor(Zig::GlobalObject* globalObject) {
     return JSValue::encode(globalObject->JSTranspilerConstructor());
-}
+  }
 
 JSTranspiler::~JSTranspiler()
 {
@@ -27865,7 +29915,7 @@ void JSTranspiler::destroy(JSCell* cell)
 {
     static_cast<JSTranspiler*>(cell)->JSTranspiler::~JSTranspiler();
 }
-
+  
 const ClassInfo JSTranspiler::s_info = { "Transpiler"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTranspiler) };
 
 void JSTranspiler::finishCreation(VM& vm)
@@ -27874,38 +29924,37 @@ void JSTranspiler::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
-JSTranspiler* JSTranspiler::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx)
-{
-    JSTranspiler* ptr = new (NotNull, JSC::allocateCell<JSTranspiler>(vm)) JSTranspiler(vm, structure, ctx);
-    ptr->finishCreation(vm);
-    return ptr;
-}
 
-extern "C" void* Transpiler__fromJS(JSC::EncodedJSValue value)
-{
-    JSC::JSValue decodedValue = JSC::JSValue::decode(value);
-    if (decodedValue.isEmpty() || !decodedValue.isCell())
-        return nullptr;
+JSTranspiler* JSTranspiler::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSTranspiler* ptr = new (NotNull, JSC::allocateCell<JSTranspiler>(vm)) JSTranspiler(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
 
-    JSC::JSCell* cell = decodedValue.asCell();
-    JSTranspiler* object = JSC::jsDynamicCast<JSTranspiler*>(cell);
+extern "C" void* Transpiler__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (decodedValue.isEmpty() || !decodedValue.isCell())
+      return nullptr;
 
-    if (!object)
-        return nullptr;
+  JSC::JSCell* cell = decodedValue.asCell();
+  JSTranspiler* object = JSC::jsDynamicCast<JSTranspiler*>(cell);
 
-    return object->wrapped();
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
 }
 
-extern "C" bool Transpiler__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr)
-{
-    JSTranspiler* object = JSC::jsDynamicCast<JSTranspiler*>(JSValue::decode(value));
-    if (!object)
-        return false;
-
-    object->m_ctx = ptr;
-    return true;
+extern "C" bool Transpiler__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSTranspiler* object = JSC::jsDynamicCast<JSTranspiler*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
 }
 
+
 extern "C" const size_t Transpiler__ptrOffset = JSTranspiler::offsetOfWrapped();
 
 void JSTranspiler::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
@@ -27920,7 +29969,7 @@ void JSTranspiler::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 
 JSObject* JSTranspiler::createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 {
-    return WebCore::JSTranspilerConstructor::create(vm, globalObject, WebCore::JSTranspilerConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSTranspilerPrototype*>(prototype));
+  return WebCore::JSTranspilerConstructor::create(vm, globalObject, WebCore::JSTranspilerConstructor::createStructure(vm, globalObject, globalObject->functionPrototype()), jsCast<WebCore::JSTranspilerPrototype*>(prototype));
 }
 
 JSObject* JSTranspiler::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
@@ -27928,28 +29977,29 @@ JSObject* JSTranspiler::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
     return JSTranspilerPrototype::create(vm, globalObject, JSTranspilerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 }
 
-extern "C" EncodedJSValue Transpiler__create(Zig::GlobalObject* globalObject, void* ptr)
-{
-    auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->JSTranspilerStructure();
-    JSTranspiler* instance = JSTranspiler::create(vm, globalObject, structure, ptr);
-
-    return JSValue::encode(instance);
-}
-std::optional<StructuredCloneableSerialize> StructuredCloneableSerialize::fromJS(JSC::JSValue value)
-{
+extern "C" EncodedJSValue Transpiler__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSTranspilerStructure();
+  JSTranspiler* instance = JSTranspiler::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}  
+  std::optional<StructuredCloneableSerialize> StructuredCloneableSerialize::fromJS(JSC::JSValue value)
+  {
     if (auto* result = jsDynamicCast<JSBlob*>(value)) {
-        return StructuredCloneableSerialize { .cppWriteBytes = SerializedScriptValue::writeBytesForBun, .zigFunction = Blob__onStructuredCloneSerialize, .tag = 254, .impl = result->wrapped() };
+      return StructuredCloneableSerialize { .cppWriteBytes = SerializedScriptValue::writeBytesForBun, .zigFunction = Blob__onStructuredCloneSerialize, .tag = 254, .impl = result->wrapped() };
     }
     return std::nullopt;
-}
-
-std::optional<JSC::EncodedJSValue> StructuredCloneableDeserialize::fromTagDeserialize(uint8_t tag, JSC::JSGlobalObject* globalObject, const uint8_t* ptr, const uint8_t* end)
-{
+  }
+  
+  std::optional<JSC::EncodedJSValue> StructuredCloneableDeserialize::fromTagDeserialize(uint8_t tag, JSC::JSGlobalObject* globalObject, const uint8_t* ptr, const uint8_t* end)
+  {
     if (tag == 254) {
-        return Blob__onStructuredCloneDeserialize(globalObject, ptr, end);
+      return Blob__onStructuredCloneDeserialize(globalObject, ptr, end);
     }
     return std::nullopt;
-}
+  }
+  
 
 } // namespace WebCore
+
diff --git a/src/bun.js/bindings/ZigGeneratedClasses.h b/src/bun.js/bindings/ZigGeneratedClasses.h
index c1d7ca99e..9b30f11ee 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses.h
+++ b/src/bun.js/bindings/ZigGeneratedClasses.h
@@ -12,2952 +12,3364 @@ namespace Zig {
 #include <wtf/NeverDestroyed.h>
 #include "SerializedScriptValue.h"
 
+
 namespace WebCore {
 using namespace Zig;
 using namespace JSC;
 
 class JSAttributeIterator final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSAttributeIterator* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSAttributeIterator, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForAttributeIterator.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForAttributeIterator = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForAttributeIterator.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForAttributeIterator = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSAttributeIterator();
-
-    void* wrapped() const { return m_ctx; }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSAttributeIterator* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSAttributeIterator, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForAttributeIterator.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForAttributeIterator = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForAttributeIterator.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForAttributeIterator = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSAttributeIterator();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSAttributeIterator, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSAttributeIterator(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+        
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSAttributeIterator, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSAttributeIterator(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
-
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSBigIntStats final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSBigIntStats* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSBigIntStats, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForBigIntStats.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBigIntStats = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForBigIntStats.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForBigIntStats = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSBigIntStats();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBigIntStats, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSBigIntStats* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSBigIntStats, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForBigIntStats.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBigIntStats = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForBigIntStats.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForBigIntStats = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSBigIntStats();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBigIntStats, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSBigIntStats(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSBigIntStats(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_atime;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_birthtime;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_ctime;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_mtime;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_atime;
+mutable JSC::WriteBarrier<JSC::Unknown> m_birthtime;
+mutable JSC::WriteBarrier<JSC::Unknown> m_ctime;
+mutable JSC::WriteBarrier<JSC::Unknown> m_mtime;
+    };
 
 class JSBlob final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSBlob* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSBlob, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForBlob.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBlob = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForBlob.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForBlob = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSBlob();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSBlob* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSBlob, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForBlob.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBlob = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForBlob.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForBlob = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSBlob();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBlob, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSBlob(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBlob, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSBlob(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    void finishCreation(JSC::VM&);
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_name;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_name;
+    };
 
 class JSBuildArtifact final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSBuildArtifact* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSBuildArtifact, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForBuildArtifact.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBuildArtifact = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForBuildArtifact.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForBuildArtifact = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSBuildArtifact();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBuildArtifact, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSBuildArtifact* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSBuildArtifact, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForBuildArtifact.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBuildArtifact = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForBuildArtifact.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForBuildArtifact = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSBuildArtifact();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBuildArtifact, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSBuildArtifact(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSBuildArtifact(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_hash;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_kind;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_loader;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_path;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_sourcemap;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_type;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_hash;
+mutable JSC::WriteBarrier<JSC::Unknown> m_kind;
+mutable JSC::WriteBarrier<JSC::Unknown> m_loader;
+mutable JSC::WriteBarrier<JSC::Unknown> m_path;
+mutable JSC::WriteBarrier<JSC::Unknown> m_sourcemap;
+mutable JSC::WriteBarrier<JSC::Unknown> m_type;
+    };
 
 class JSBuildMessage final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSBuildMessage* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSBuildMessage, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForBuildMessage.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBuildMessage = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForBuildMessage.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForBuildMessage = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSBuildMessage();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBuildMessage, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSBuildMessage* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSBuildMessage, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForBuildMessage.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForBuildMessage = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForBuildMessage.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForBuildMessage = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSBuildMessage();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSBuildMessage, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSBuildMessage(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSBuildMessage(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_level;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_message;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_position;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_level;
+mutable JSC::WriteBarrier<JSC::Unknown> m_message;
+mutable JSC::WriteBarrier<JSC::Unknown> m_position;
+    };
 
 class JSComment final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSComment* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSComment, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForComment.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForComment = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForComment.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForComment = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSComment();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSComment* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSComment, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForComment.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForComment = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForComment.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForComment = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSComment();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSComment, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSComment(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSComment, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSComment(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSCrypto final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSCrypto* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSCrypto, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForCrypto.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCrypto = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForCrypto.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForCrypto = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSCrypto();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSCrypto* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSCrypto, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForCrypto.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCrypto = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForCrypto.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForCrypto = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSCrypto();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSCrypto, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSCrypto(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSCrypto, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSCrypto(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSCryptoHasher final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSCryptoHasher* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSCryptoHasher, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForCryptoHasher.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoHasher = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForCryptoHasher.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForCryptoHasher = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSCryptoHasher();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSCryptoHasher* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSCryptoHasher, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForCryptoHasher.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForCryptoHasher = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForCryptoHasher.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForCryptoHasher = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSCryptoHasher();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSCryptoHasher, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSCryptoHasher(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSCryptoHasher, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSCryptoHasher(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    void finishCreation(JSC::VM&);
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_algorithms;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_algorithm;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_algorithms;
+mutable JSC::WriteBarrier<JSC::Unknown> m_algorithm;
+    };
 
 class JSDebugHTTPSServer final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSDebugHTTPSServer* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSDebugHTTPSServer, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForDebugHTTPSServer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDebugHTTPSServer = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForDebugHTTPSServer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForDebugHTTPSServer = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSDebugHTTPSServer();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDebugHTTPSServer, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSDebugHTTPSServer* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSDebugHTTPSServer, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForDebugHTTPSServer.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDebugHTTPSServer = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForDebugHTTPSServer.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForDebugHTTPSServer = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSDebugHTTPSServer();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDebugHTTPSServer, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSDebugHTTPSServer(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSDebugHTTPSServer(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_address;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_id;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_address;
+mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
+mutable JSC::WriteBarrier<JSC::Unknown> m_id;
+    };
 
 class JSDebugHTTPServer final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSDebugHTTPServer* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSDebugHTTPServer, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForDebugHTTPServer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDebugHTTPServer = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForDebugHTTPServer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForDebugHTTPServer = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSDebugHTTPServer();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDebugHTTPServer, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSDebugHTTPServer* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSDebugHTTPServer, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForDebugHTTPServer.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDebugHTTPServer = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForDebugHTTPServer.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForDebugHTTPServer = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSDebugHTTPServer();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDebugHTTPServer, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSDebugHTTPServer(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSDebugHTTPServer(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_address;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_id;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_address;
+mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
+mutable JSC::WriteBarrier<JSC::Unknown> m_id;
+    };
 
 class JSDirent final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSDirent* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSDirent, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForDirent.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDirent = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForDirent.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForDirent = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSDirent();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDirent, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSDirent* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSDirent, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForDirent.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDirent = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForDirent.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForDirent = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSDirent();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDirent, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSDirent(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSDirent(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_name;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_name;
+    };
 
 class JSDocEnd final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSDocEnd* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSDocEnd, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForDocEnd.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDocEnd = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForDocEnd.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForDocEnd = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSDocEnd();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSDocEnd* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSDocEnd, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForDocEnd.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDocEnd = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForDocEnd.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForDocEnd = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSDocEnd();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDocEnd, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSDocEnd(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDocEnd, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSDocEnd(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSDocType final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSDocType* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSDocType, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForDocType.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDocType = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForDocType.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForDocType = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSDocType();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDocType, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSDocType* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSDocType, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForDocType.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForDocType = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForDocType.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForDocType = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSDocType();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSDocType, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSDocType(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSDocType(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_name;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_publicId;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_systemId;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_name;
+mutable JSC::WriteBarrier<JSC::Unknown> m_publicId;
+mutable JSC::WriteBarrier<JSC::Unknown> m_systemId;
+    };
 
 class JSElement final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSElement* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSElement, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForElement.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForElement = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForElement.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForElement = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSElement();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSElement, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSElement* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSElement, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForElement.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForElement = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForElement.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForElement = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSElement();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSElement, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSElement(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSElement(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_namespaceURI;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_namespaceURI;
+    };
 
 class JSEndTag final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSEndTag* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSEndTag, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForEndTag.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForEndTag = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForEndTag.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForEndTag = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSEndTag();
-
-    void* wrapped() const { return m_ctx; }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSEndTag* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSEndTag, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForEndTag.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForEndTag = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForEndTag.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForEndTag = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSEndTag();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSEndTag, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSEndTag(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+        
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSEndTag, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSEndTag(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
-
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSExpect final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSExpect* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSExpect, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForExpect.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpect = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForExpect.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpect = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSExpect();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpect, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSExpect* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSExpect, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForExpect.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpect = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForExpect.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForExpect = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSExpect();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpect, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSExpect(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSExpect(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_capturedValue;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_resultValue;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_capturedValue;
+mutable JSC::WriteBarrier<JSC::Unknown> m_resultValue;
+    };
 
 class JSExpectAny final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSExpectAny* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSExpectAny, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForExpectAny.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectAny = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForExpectAny.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectAny = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSExpectAny();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectAny, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSExpectAny* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSExpectAny, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForExpectAny.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectAny = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForExpectAny.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectAny = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSExpectAny();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectAny, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSExpectAny(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSExpectAny(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_constructorValue;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_constructorValue;
+    };
 
 class JSExpectAnything final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSExpectAnything* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSExpectAnything, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForExpectAnything.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectAnything = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForExpectAnything.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectAnything = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSExpectAnything();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSExpectAnything* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSExpectAnything, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForExpectAnything.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectAnything = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForExpectAnything.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectAnything = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSExpectAnything();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectAnything, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSExpectAnything(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectAnything, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSExpectAnything(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSExpectArrayContaining final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSExpectArrayContaining* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSExpectArrayContaining, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForExpectArrayContaining.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectArrayContaining = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForExpectArrayContaining.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectArrayContaining = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSExpectArrayContaining();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectArrayContaining, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSExpectArrayContaining* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSExpectArrayContaining, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForExpectArrayContaining.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectArrayContaining = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForExpectArrayContaining.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectArrayContaining = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSExpectArrayContaining();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectArrayContaining, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSExpectArrayContaining(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSExpectArrayContaining(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_arrayValue;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_arrayValue;
+    };
 
 class JSExpectStringContaining final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSExpectStringContaining* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSExpectStringContaining, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForExpectStringContaining.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectStringContaining = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForExpectStringContaining.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectStringContaining = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSExpectStringContaining();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectStringContaining, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSExpectStringContaining* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSExpectStringContaining, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForExpectStringContaining.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectStringContaining = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForExpectStringContaining.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectStringContaining = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSExpectStringContaining();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectStringContaining, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSExpectStringContaining(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSExpectStringContaining(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_stringValue;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_stringValue;
+    };
 
 class JSExpectStringMatching final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSExpectStringMatching* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSExpectStringMatching, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForExpectStringMatching.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectStringMatching = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForExpectStringMatching.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectStringMatching = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSExpectStringMatching();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectStringMatching, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSExpectStringMatching* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSExpectStringMatching, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForExpectStringMatching.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForExpectStringMatching = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForExpectStringMatching.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForExpectStringMatching = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSExpectStringMatching();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSExpectStringMatching, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSExpectStringMatching(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSExpectStringMatching(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_testValue;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_testValue;
+    };
 
 class JSFFI final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSFFI* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSFFI, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForFFI.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFFI = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForFFI.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForFFI = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSFFI();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSFFI* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSFFI, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForFFI.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFFI = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForFFI.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForFFI = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSFFI();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSFFI, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSFFI(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSFFI, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSFFI(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    void finishCreation(JSC::VM&);
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_symbolsValue;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_symbolsValue;
+    };
 
 class JSFSWatcher final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSFSWatcher* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSFSWatcher, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForFSWatcher.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFSWatcher = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForFSWatcher.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForFSWatcher = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSFSWatcher();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSFSWatcher, m_ctx); }
-
-    void* m_ctx { nullptr };
-
-    JSFSWatcher(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-        m_weakThis = JSC::Weak<JSFSWatcher>(this, getOwner());
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSFSWatcher* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSFSWatcher, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForFSWatcher.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFSWatcher = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForFSWatcher.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForFSWatcher = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSFSWatcher();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSFSWatcher, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSFSWatcher(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            m_weakThis = JSC::Weak<JSFSWatcher>(this, getOwner());
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void finishCreation(JSC::VM&);
+        
 
+        
     JSC::Weak<JSFSWatcher> m_weakThis;
+   
 
     static bool hasPendingActivity(void* ctx);
 
     class Owner final : public JSC::WeakHandleOwner {
-    public:
-        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
-        {
-            auto* controller = JSC::jsCast<JSFSWatcher*>(handle.slot()->asCell());
-            if (JSFSWatcher::hasPendingActivity(controller->wrapped())) {
-                if (UNLIKELY(reason))
+      public:
+          bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
+          {
+              auto* controller = JSC::jsCast<JSFSWatcher*>(handle.slot()->asCell());
+              if (JSFSWatcher::hasPendingActivity(controller->wrapped())) {
+                  if (UNLIKELY(reason))
                     *reason = "has pending activity";
-                return true;
-            }
-
-            return visitor.containsOpaqueRoot(context);
-        }
-        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+                  return true;
+              }
+
+              return visitor.containsOpaqueRoot(context);
+          }
+          void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+      };
+  
+      static JSC::WeakHandleOwner* getOwner()
+      {
+          static NeverDestroyed<Owner> m_owner;
+          return &m_owner.get();
+      }
+      
+
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+
+        mutable JSC::WriteBarrier<JSC::Unknown> m_listener;
     };
 
-    static JSC::WeakHandleOwner* getOwner()
-    {
-        static NeverDestroyed<Owner> m_owner;
-        return &m_owner.get();
-    }
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_listener;
-};
-
 class JSFileSystemRouter final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSFileSystemRouter* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSFileSystemRouter, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForFileSystemRouter.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFileSystemRouter = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForFileSystemRouter.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForFileSystemRouter = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSFileSystemRouter();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSFileSystemRouter, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSFileSystemRouter* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSFileSystemRouter, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForFileSystemRouter.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForFileSystemRouter = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForFileSystemRouter.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForFileSystemRouter = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSFileSystemRouter();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSFileSystemRouter, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSFileSystemRouter(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSFileSystemRouter(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_origin;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_routes;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_style;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_origin;
+mutable JSC::WriteBarrier<JSC::Unknown> m_routes;
+mutable JSC::WriteBarrier<JSC::Unknown> m_style;
+    };
 
 class JSHTMLRewriter final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSHTMLRewriter* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSHTMLRewriter, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForHTMLRewriter.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHTMLRewriter = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForHTMLRewriter.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForHTMLRewriter = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSHTMLRewriter();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSHTMLRewriter* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSHTMLRewriter, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForHTMLRewriter.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHTMLRewriter = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForHTMLRewriter.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForHTMLRewriter = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSHTMLRewriter();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSHTMLRewriter, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSHTMLRewriter(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSHTMLRewriter, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSHTMLRewriter(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSHTTPSServer final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSHTTPSServer* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSHTTPSServer, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForHTTPSServer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHTTPSServer = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForHTTPSServer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForHTTPSServer = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSHTTPSServer();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSHTTPSServer, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSHTTPSServer* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSHTTPSServer, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForHTTPSServer.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHTTPSServer = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForHTTPSServer.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForHTTPSServer = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSHTTPSServer();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSHTTPSServer, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSHTTPSServer(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSHTTPSServer(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_address;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_id;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_address;
+mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
+mutable JSC::WriteBarrier<JSC::Unknown> m_id;
+    };
 
 class JSHTTPServer final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSHTTPServer* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSHTTPServer, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForHTTPServer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHTTPServer = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForHTTPServer.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForHTTPServer = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSHTTPServer();
-
-    void* wrapped() const { return m_ctx; }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSHTTPServer* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSHTTPServer, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForHTTPServer.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForHTTPServer = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForHTTPServer.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForHTTPServer = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSHTTPServer();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSHTTPServer, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSHTTPServer(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+        
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSHTTPServer, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    JSHTTPServer(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
 
-    void finishCreation(JSC::VM&);
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_address;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_id;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_address;
+mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
+mutable JSC::WriteBarrier<JSC::Unknown> m_id;
+    };
 
 class JSListener final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSListener* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSListener, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForListener.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForListener = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForListener.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForListener = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSListener();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSListener, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSListener* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSListener, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForListener.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForListener = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForListener.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForListener = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSListener();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSListener, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSListener(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSListener(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_unix;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
+mutable JSC::WriteBarrier<JSC::Unknown> m_unix;
+    };
 
 class JSMD4 final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSMD4* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSMD4, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForMD4.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD4 = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForMD4.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForMD4 = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSMD4();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSMD4* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSMD4, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForMD4.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD4 = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForMD4.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForMD4 = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSMD4();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMD4, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSMD4(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMD4, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSMD4(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSMD5 final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSMD5* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSMD5, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForMD5.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD5 = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForMD5.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForMD5 = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSMD5();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSMD5* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSMD5, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForMD5.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMD5 = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForMD5.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForMD5 = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSMD5();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMD5, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSMD5(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMD5, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSMD5(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSMatchedRoute final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSMatchedRoute* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSMatchedRoute, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForMatchedRoute.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMatchedRoute = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForMatchedRoute.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForMatchedRoute = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSMatchedRoute();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMatchedRoute, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSMatchedRoute* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSMatchedRoute, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForMatchedRoute.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForMatchedRoute = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForMatchedRoute.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForMatchedRoute = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSMatchedRoute();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSMatchedRoute, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSMatchedRoute(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSMatchedRoute(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_filePath;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_kind;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_name;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_params;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_pathname;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_query;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_scriptSrc;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_filePath;
+mutable JSC::WriteBarrier<JSC::Unknown> m_kind;
+mutable JSC::WriteBarrier<JSC::Unknown> m_name;
+mutable JSC::WriteBarrier<JSC::Unknown> m_params;
+mutable JSC::WriteBarrier<JSC::Unknown> m_pathname;
+mutable JSC::WriteBarrier<JSC::Unknown> m_query;
+mutable JSC::WriteBarrier<JSC::Unknown> m_scriptSrc;
+    };
 
 class JSNodeJSFS final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSNodeJSFS* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSNodeJSFS, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForNodeJSFS.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForNodeJSFS = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForNodeJSFS.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForNodeJSFS = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSNodeJSFS();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSNodeJSFS* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSNodeJSFS, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForNodeJSFS.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForNodeJSFS = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForNodeJSFS.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForNodeJSFS = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(ObjectType), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSNodeJSFS();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSNodeJSFS, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSNodeJSFS(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSNodeJSFS, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSNodeJSFS(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSRequest final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSRequest* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSRequest, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForRequest.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForRequest = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForRequest.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForRequest = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSRequest();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSRequest, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSRequest* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSRequest, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForRequest.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForRequest = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForRequest.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForRequest = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSRequest();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSRequest, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSRequest(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSRequest(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_body;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_signal;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_url;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_body;
+mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
+mutable JSC::WriteBarrier<JSC::Unknown> m_signal;
+mutable JSC::WriteBarrier<JSC::Unknown> m_url;
+    };
 
 class JSResolveMessage final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSResolveMessage* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSResolveMessage, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForResolveMessage.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResolveMessage = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForResolveMessage.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForResolveMessage = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSResolveMessage();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSResolveMessage, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSResolveMessage* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSResolveMessage, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForResolveMessage.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResolveMessage = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForResolveMessage.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForResolveMessage = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSResolveMessage();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSResolveMessage, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSResolveMessage(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSResolveMessage(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_code;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_importKind;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_level;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_message;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_position;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_referrer;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_specifier;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_code;
+mutable JSC::WriteBarrier<JSC::Unknown> m_importKind;
+mutable JSC::WriteBarrier<JSC::Unknown> m_level;
+mutable JSC::WriteBarrier<JSC::Unknown> m_message;
+mutable JSC::WriteBarrier<JSC::Unknown> m_position;
+mutable JSC::WriteBarrier<JSC::Unknown> m_referrer;
+mutable JSC::WriteBarrier<JSC::Unknown> m_specifier;
+    };
 
 class JSResponse final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSResponse* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSResponse, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForResponse.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResponse = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForResponse.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForResponse = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSResponse();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSResponse, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSResponse* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSResponse, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForResponse.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForResponse = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForResponse.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForResponse = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSResponse();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSResponse, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSResponse(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSResponse(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_body;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_statusText;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_url;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_body;
+mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
+mutable JSC::WriteBarrier<JSC::Unknown> m_statusText;
+mutable JSC::WriteBarrier<JSC::Unknown> m_url;
+    };
 
 class JSSHA1 final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSSHA1* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA1, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA1.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA1 = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA1.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA1 = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSSHA1();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSSHA1* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA1, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA1.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA1 = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA1.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA1 = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSSHA1();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA1, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSSHA1(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA1, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSSHA1(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSSHA224 final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSSHA224* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA224, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA224.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA224 = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA224.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA224 = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSSHA224();
-
-    void* wrapped() const { return m_ctx; }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSSHA224* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA224, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA224.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA224 = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA224.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA224 = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSSHA224();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA224, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSSHA224(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+        
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA224, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSSHA224(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
-
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSSHA256 final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSSHA256* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA256, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA256.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA256 = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA256.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA256 = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSSHA256();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSSHA256* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA256, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA256.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA256 = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA256.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA256 = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSSHA256();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA256, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSSHA256(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA256, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSSHA256(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSSHA384 final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSSHA384* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA384, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA384.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA384 = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA384.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA384 = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSSHA384();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSSHA384* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA384, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA384.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA384 = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA384.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA384 = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSSHA384();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA384, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSSHA384(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA384, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSSHA384(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSSHA512 final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSSHA512* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA512, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA512.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512 = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA512.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512 = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSSHA512();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSSHA512* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA512, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA512.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512 = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA512.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512 = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSSHA512();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA512, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSSHA512(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA512, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSSHA512(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSSHA512_256 final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSSHA512_256* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSHA512_256, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSHA512_256.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512_256 = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSHA512_256.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512_256 = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSSHA512_256();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSSHA512_256* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSHA512_256, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSHA512_256.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSHA512_256 = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSHA512_256.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSHA512_256 = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSSHA512_256();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA512_256, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSSHA512_256(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSHA512_256, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
 
-    JSSHA512_256(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
-};
+        
+    };
 
 class JSServerWebSocket final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSServerWebSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSServerWebSocket, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForServerWebSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForServerWebSocket = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForServerWebSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForServerWebSocket = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSServerWebSocket();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSServerWebSocket, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSServerWebSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSServerWebSocket, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForServerWebSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForServerWebSocket = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForServerWebSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForServerWebSocket = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSServerWebSocket();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSServerWebSocket, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSServerWebSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSServerWebSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_data;
+mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
+    };
 
 class JSStatWatcher final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSStatWatcher* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSStatWatcher, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForStatWatcher.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForStatWatcher = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForStatWatcher.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForStatWatcher = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSStatWatcher();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSStatWatcher, m_ctx); }
-
-    void* m_ctx { nullptr };
-
-    JSStatWatcher(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-        m_weakThis = JSC::Weak<JSStatWatcher>(this, getOwner());
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSStatWatcher* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSStatWatcher, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForStatWatcher.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForStatWatcher = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForStatWatcher.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForStatWatcher = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSStatWatcher();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSStatWatcher, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSStatWatcher(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            m_weakThis = JSC::Weak<JSStatWatcher>(this, getOwner());
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void finishCreation(JSC::VM&);
+        
 
+        
     JSC::Weak<JSStatWatcher> m_weakThis;
+   
 
     static bool hasPendingActivity(void* ctx);
 
     class Owner final : public JSC::WeakHandleOwner {
-    public:
-        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
-        {
-            auto* controller = JSC::jsCast<JSStatWatcher*>(handle.slot()->asCell());
-            if (JSStatWatcher::hasPendingActivity(controller->wrapped())) {
-                if (UNLIKELY(reason))
+      public:
+          bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
+          {
+              auto* controller = JSC::jsCast<JSStatWatcher*>(handle.slot()->asCell());
+              if (JSStatWatcher::hasPendingActivity(controller->wrapped())) {
+                  if (UNLIKELY(reason))
                     *reason = "has pending activity";
-                return true;
-            }
-
-            return visitor.containsOpaqueRoot(context);
-        }
-        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+                  return true;
+              }
+
+              return visitor.containsOpaqueRoot(context);
+          }
+          void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+      };
+  
+      static JSC::WeakHandleOwner* getOwner()
+      {
+          static NeverDestroyed<Owner> m_owner;
+          return &m_owner.get();
+      }
+      
+
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+
+        mutable JSC::WriteBarrier<JSC::Unknown> m_listener;
     };
 
-    static JSC::WeakHandleOwner* getOwner()
-    {
-        static NeverDestroyed<Owner> m_owner;
-        return &m_owner.get();
-    }
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_listener;
-};
-
 class JSStats final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSStats* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSStats, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForStats.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForStats = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForStats.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForStats = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSStats();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSStats, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSStats* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSStats, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForStats.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForStats = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForStats.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForStats = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSStats();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSStats, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSStats(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSStats(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_atime;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_ctime;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_mtime;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_atime;
+mutable JSC::WriteBarrier<JSC::Unknown> m_ctime;
+mutable JSC::WriteBarrier<JSC::Unknown> m_mtime;
+    };
 
 class JSSubprocess final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSSubprocess* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSSubprocess, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForSubprocess.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSubprocess = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForSubprocess.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForSubprocess = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSSubprocess();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSubprocess, m_ctx); }
-
-    void* m_ctx { nullptr };
-
-    JSSubprocess(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-        m_weakThis = JSC::Weak<JSSubprocess>(this, getOwner());
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSSubprocess* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSSubprocess, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForSubprocess.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForSubprocess = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForSubprocess.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForSubprocess = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSSubprocess();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSSubprocess, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSSubprocess(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            m_weakThis = JSC::Weak<JSSubprocess>(this, getOwner());
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void finishCreation(JSC::VM&);
+        
 
+        
     JSC::Weak<JSSubprocess> m_weakThis;
+   
 
     static bool hasPendingActivity(void* ctx);
 
     class Owner final : public JSC::WeakHandleOwner {
-    public:
-        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
-        {
-            auto* controller = JSC::jsCast<JSSubprocess*>(handle.slot()->asCell());
-            if (JSSubprocess::hasPendingActivity(controller->wrapped())) {
-                if (UNLIKELY(reason))
+      public:
+          bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
+          {
+              auto* controller = JSC::jsCast<JSSubprocess*>(handle.slot()->asCell());
+              if (JSSubprocess::hasPendingActivity(controller->wrapped())) {
+                  if (UNLIKELY(reason))
                     *reason = "has pending activity";
-                return true;
-            }
-
-            return visitor.containsOpaqueRoot(context);
-        }
-        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+                  return true;
+              }
+
+              return visitor.containsOpaqueRoot(context);
+          }
+          void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+      };
+  
+      static JSC::WeakHandleOwner* getOwner()
+      {
+          static NeverDestroyed<Owner> m_owner;
+          return &m_owner.get();
+      }
+      
+
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+
+        mutable JSC::WriteBarrier<JSC::Unknown> m_stderr;
+mutable JSC::WriteBarrier<JSC::Unknown> m_stdin;
+mutable JSC::WriteBarrier<JSC::Unknown> m_stdout;
     };
 
-    static JSC::WeakHandleOwner* getOwner()
-    {
-        static NeverDestroyed<Owner> m_owner;
-        return &m_owner.get();
-    }
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_stderr;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_stdin;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_stdout;
-};
-
 class JSTCPSocket final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSTCPSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSTCPSocket, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTCPSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTCPSocket = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTCPSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTCPSocket = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSTCPSocket();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTCPSocket, m_ctx); }
-
-    void* m_ctx { nullptr };
-
-    JSTCPSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-        m_weakThis = JSC::Weak<JSTCPSocket>(this, getOwner());
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSTCPSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTCPSocket, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTCPSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTCPSocket = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTCPSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTCPSocket = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSTCPSocket();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTCPSocket, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSTCPSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            m_weakThis = JSC::Weak<JSTCPSocket>(this, getOwner());
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void finishCreation(JSC::VM&);
+        
 
+        
     JSC::Weak<JSTCPSocket> m_weakThis;
+   
 
     static bool hasPendingActivity(void* ctx);
 
     class Owner final : public JSC::WeakHandleOwner {
-    public:
-        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
-        {
-            auto* controller = JSC::jsCast<JSTCPSocket*>(handle.slot()->asCell());
-            if (JSTCPSocket::hasPendingActivity(controller->wrapped())) {
-                if (UNLIKELY(reason))
+      public:
+          bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
+          {
+              auto* controller = JSC::jsCast<JSTCPSocket*>(handle.slot()->asCell());
+              if (JSTCPSocket::hasPendingActivity(controller->wrapped())) {
+                  if (UNLIKELY(reason))
                     *reason = "has pending activity";
-                return true;
-            }
-
-            return visitor.containsOpaqueRoot(context);
-        }
-        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+                  return true;
+              }
+
+              return visitor.containsOpaqueRoot(context);
+          }
+          void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+      };
+  
+      static JSC::WeakHandleOwner* getOwner()
+      {
+          static NeverDestroyed<Owner> m_owner;
+          return &m_owner.get();
+      }
+      
+
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+
+        mutable JSC::WriteBarrier<JSC::Unknown> m_data;
+mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
     };
 
-    static JSC::WeakHandleOwner* getOwner()
-    {
-        static NeverDestroyed<Owner> m_owner;
-        return &m_owner.get();
-    }
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
-};
-
 class JSTLSSocket final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSTLSSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSTLSSocket, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTLSSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTLSSocket = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTLSSocket.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTLSSocket = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSTLSSocket();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTLSSocket, m_ctx); }
-
-    void* m_ctx { nullptr };
-
-    JSTLSSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-        m_weakThis = JSC::Weak<JSTLSSocket>(this, getOwner());
-    }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSTLSSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTLSSocket, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTLSSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTLSSocket = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTLSSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTLSSocket = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSTLSSocket();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTLSSocket, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSTLSSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            m_weakThis = JSC::Weak<JSTLSSocket>(this, getOwner());
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void finishCreation(JSC::VM&);
+        
 
+        
     JSC::Weak<JSTLSSocket> m_weakThis;
+   
 
     static bool hasPendingActivity(void* ctx);
 
     class Owner final : public JSC::WeakHandleOwner {
-    public:
-        bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
-        {
-            auto* controller = JSC::jsCast<JSTLSSocket*>(handle.slot()->asCell());
-            if (JSTLSSocket::hasPendingActivity(controller->wrapped())) {
-                if (UNLIKELY(reason))
+      public:
+          bool isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void* context, JSC::AbstractSlotVisitor& visitor, const char** reason) final
+          {
+              auto* controller = JSC::jsCast<JSTLSSocket*>(handle.slot()->asCell());
+              if (JSTLSSocket::hasPendingActivity(controller->wrapped())) {
+                  if (UNLIKELY(reason))
                     *reason = "has pending activity";
-                return true;
-            }
-
-            return visitor.containsOpaqueRoot(context);
-        }
-        void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+                  return true;
+              }
+
+              return visitor.containsOpaqueRoot(context);
+          }
+          void finalize(JSC::Handle<JSC::Unknown>, void* context) final {}
+      };
+  
+      static JSC::WeakHandleOwner* getOwner()
+      {
+          static NeverDestroyed<Owner> m_owner;
+          return &m_owner.get();
+      }
+      
+
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
+
+
+        mutable JSC::WriteBarrier<JSC::Unknown> m_data;
+mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
     };
 
-    static JSC::WeakHandleOwner* getOwner()
-    {
-        static NeverDestroyed<Owner> m_owner;
-        return &m_owner.get();
-    }
-
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
-
-    mutable JSC::WriteBarrier<JSC::Unknown> m_data;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
-};
-
 class JSTextChunk final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSTextChunk* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSTextChunk, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTextChunk.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTextChunk = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTextChunk.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTextChunk = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSTextChunk();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTextChunk, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSTextChunk* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTextChunk, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTextChunk.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTextChunk = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTextChunk.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTextChunk = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSTextChunk();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTextChunk, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSTextChunk(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSTextChunk(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_lastInTextNode;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_lastInTextNode;
+    };
 
 class JSTextDecoder final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSTextDecoder* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSTextDecoder, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTextDecoder.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTextDecoder = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTextDecoder.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTextDecoder = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSTextDecoder();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTextDecoder, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSTextDecoder* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTextDecoder, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTextDecoder.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTextDecoder = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTextDecoder.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTextDecoder = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSTextDecoder();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTextDecoder, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSTextDecoder(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSTextDecoder(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_encoding;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_encoding;
+    };
 
 class JSTimeout final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSTimeout* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSTimeout, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTimeout.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTimeout = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTimeout.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTimeout = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    ;
-
-    ~JSTimeout();
-
-    void* wrapped() const { return m_ctx; }
-
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
-
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTimeout, m_ctx); }
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSTimeout* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTimeout, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTimeout.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTimeout = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTimeout.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTimeout = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        ;
+    
+        ~JSTimeout();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTimeout, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSTimeout(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* m_ctx { nullptr };
+        
 
-    JSTimeout(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
+        
 
-    void finishCreation(JSC::VM&);
+        DECLARE_VISIT_CHILDREN;
+template<typename Visitor> void visitAdditionalChildren(Visitor&);
+DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    DECLARE_VISIT_CHILDREN;
-    template<typename Visitor> void visitAdditionalChildren(Visitor&);
-    DECLARE_VISIT_OUTPUT_CONSTRAINTS;
 
-    mutable JSC::WriteBarrier<JSC::Unknown> m_arguments;
-    mutable JSC::WriteBarrier<JSC::Unknown> m_callback;
-};
+        mutable JSC::WriteBarrier<JSC::Unknown> m_arguments;
+mutable JSC::WriteBarrier<JSC::Unknown> m_callback;
+    };
 
 class JSTranspiler final : public JSC::JSDestructibleObject {
-public:
-    using Base = JSC::JSDestructibleObject;
-    static JSTranspiler* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
-
-    DECLARE_EXPORT_INFO;
-    template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
-    {
-        if constexpr (mode == JSC::SubspaceAccess::Concurrently)
-            return nullptr;
-        return WebCore::subspaceForImpl<JSTranspiler, WebCore::UseCustomHeapCellType::No>(
-            vm,
-            [](auto& spaces) { return spaces.m_clientSubspaceForTranspiler.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTranspiler = std::forward<decltype(space)>(space); },
-            [](auto& spaces) { return spaces.m_subspaceForTranspiler.get(); },
-            [](auto& spaces, auto&& space) { spaces.m_subspaceForTranspiler = std::forward<decltype(space)>(space); });
-    }
-
-    static void destroy(JSC::JSCell*);
-    static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
-    {
-        return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
-    }
-
-    static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
-    static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
-
-    ~JSTranspiler();
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSTranspiler* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTranspiler, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTranspiler.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTranspiler = std::forward<decltype(space)>(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTranspiler.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTranspiler = std::forward<decltype(space)>(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+        static JSObject* createConstructor(VM& vm, JSGlobalObject* globalObject, JSValue prototype);
+    
+        ~JSTranspiler();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTranspiler, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSTranspiler(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+            
+        }
+    
+        void finishCreation(JSC::VM&);
 
-    void* wrapped() const { return m_ctx; }
+        
 
-    void detach()
-    {
-        m_ctx = nullptr;
-    }
+        
 
-    static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
-    static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTranspiler, m_ctx); }
+        
 
-    void* m_ctx { nullptr };
+        
+    };
 
-    JSTranspiler(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
-        : Base(vm, structure)
-    {
-        m_ctx = sinkPtr;
-    }
 
-    void finishCreation(JSC::VM&);
-};
 
 class StructuredCloneableSerialize {
-public:
+  public:
+
     void (*cppWriteBytes)(CloneSerializer*, const uint8_t*, uint32_t);
 
     std::function<void(void*, JSC::JSGlobalObject*, void*, void (*)(CloneSerializer*, const uint8_t*, uint32_t))> zigFunction;
@@ -2970,13 +3382,14 @@ public:
     static std::optional<StructuredCloneableSerialize> fromJS(JSC::JSValue);
     void write(CloneSerializer* serializer, JSC::JSGlobalObject* globalObject)
     {
-        zigFunction(impl, globalObject, serializer, cppWriteBytes);
+      zigFunction(impl, globalObject, serializer, cppWriteBytes);
     }
 };
 
 class StructuredCloneableDeserialize {
-public:
+  public:
     static std::optional<JSC::EncodedJSValue> fromTagDeserialize(uint8_t tag, JSC::JSGlobalObject*, const uint8_t*, const uint8_t*);
 };
 
 }
+
diff --git a/src/bun.js/bindings/generated_classes.zig b/src/bun.js/bindings/generated_classes.zig
index c4f63084b..b61c644b6 100644
--- a/src/bun.js/bindings/generated_classes.zig
+++ b/src/bun.js/bindings/generated_classes.zig
@@ -14,7 +14,7 @@
 ///  5. make clean-bindings && make bindings -j10
 ///
 const JSC = @import("root").bun.JSC;
-const Classes = @import("./generated_classes_list.zig").Classes;
+const Classes = JSC.GeneratedClassesList;
 const Environment = @import("../../env.zig");
 const std = @import("std");
 
diff --git a/src/bun.js/node/node.classes.ts b/src/bun.js/node/node.classes.ts
index 46c25ad06..4ed5b9b2e 100644
--- a/src/bun.js/node/node.classes.ts
+++ b/src/bun.js/node/node.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/resolve_message.classes.ts b/src/bun.js/resolve_message.classes.ts
index 3e3c6d083..5bdd08eac 100644
--- a/src/bun.js/resolve_message.classes.ts
+++ b/src/bun.js/resolve_message.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "./scripts/class-definitions";
+import { define } from "../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/test/jest.classes.ts b/src/bun.js/test/jest.classes.ts
index f10d9fb37..8e9a21e92 100644
--- a/src/bun.js/test/jest.classes.ts
+++ b/src/bun.js/test/jest.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/webcore/encoding.classes.ts b/src/bun.js/webcore/encoding.classes.ts
index 7114f210e..7fd70406f 100644
--- a/src/bun.js/webcore/encoding.classes.ts
+++ b/src/bun.js/webcore/encoding.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/webcore/response.classes.ts b/src/bun.js/webcore/response.classes.ts
index 6f3c05aa4..6ce2f17f8 100644
--- a/src/bun.js/webcore/response.classes.ts
+++ b/src/bun.js/webcore/response.classes.ts
@@ -1,4 +1,4 @@
-import { define } from "../scripts/class-definitions";
+import { define } from "../../codegen/class-definitions";
 
 export default [
   define({
diff --git a/src/bun.js/scripts/class-definitions.ts b/src/codegen/class-definitions.ts
index e7dd8bd4c..e7dd8bd4c 100644
--- a/src/bun.js/scripts/class-definitions.ts
+++ b/src/codegen/class-definitions.ts
diff --git a/src/codegen/create-hash-table.ts b/src/codegen/create-hash-table.ts
new file mode 100644
index 000000000..776abfdea
--- /dev/null
+++ b/src/codegen/create-hash-table.ts
@@ -0,0 +1,23 @@
+import { spawn } from "bun";
+import path from "path";
+
+const input = process.argv[2];
+const out_dir = process.argv[3];
+
+const create_hash_table = path.join(import.meta.dir, "./create_hash_table");
+
+console.time("Generate LUT");
+const { stdout, exited } = spawn({
+  cmd: [create_hash_table, input],
+  stdout: "pipe",
+  stderr: "inherit",
+});
+await exited;
+let str = await new Response(stdout).text();
+str = str.replaceAll(/^\/\/.*$/gm, "");
+str = str.replaceAll(/^#include.*$/gm, "");
+str = str.replaceAll(`namespace JSC {`, "");
+str = str.replaceAll(`} // namespace JSC`, "");
+str = "// File generated via `make static-hash-table` / `make cpp`\n" + str.trim() + "\n";
+await Bun.write(input.replace(/\.cpp$/, ".lut.h").replace(/(\.lut)?\.txt$/, ".lut.h"), str);
+console.log("Wrote", path.join(out_dir, path.basename(process.cwd(), input.replace(/\.cpp$/, ".lut.h"))));
diff --git a/src/bun.js/scripts/create_hash_table b/src/codegen/create_hash_table
index bd604ceaa..bd604ceaa 100755
--- a/src/bun.js/scripts/create_hash_table
+++ b/src/codegen/create_hash_table
diff --git a/src/codegen/generate-classes.ts b/src/codegen/generate-classes.ts
index e1e449338..2ee0fb038 100644
--- a/src/codegen/generate-classes.ts
+++ b/src/codegen/generate-classes.ts
@@ -2,7 +2,7 @@
 import { unlinkSync } from "fs";
 import { readdirSync } from "fs";
 import { resolve } from "path";
-import type { Field, ClassDefinition } from "../bun.js/scripts/class-definitions";
+import type { Field, ClassDefinition } from "./class-definitions";
 
 const CommonIdentifiers = {
   "name": true,
@@ -1681,56 +1681,33 @@ const ZIG_GENERATED_CLASSES_HEADER = `
 ///        - pub usingnamespace JSC.Codegen.JSMyClassName;
 ///  5. make clean-bindings && make bindings -j10
 ///  
-const JSC = @import("root").bun.JSC;
-const Classes = @import("./generated_classes_list.zig").Classes;
-const Environment = @import("../../env.zig");
+const bun = @import("root").bun;
+const JSC = bun.JSC;
+const Classes = JSC.GeneratedClassesList;
+const Environment = bun.Environment;
 const std = @import("std");
 
 pub const StaticGetterType = fn(*JSC.JSGlobalObject, JSC.JSValue, JSC.JSValue) callconv(.C) JSC.JSValue;
 pub const StaticSetterType = fn(*JSC.JSGlobalObject, JSC.JSValue, JSC.JSValue, JSC.JSValue) callconv(.C) bool;
 pub const StaticCallbackType = fn(*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
 
-
-
 `;
 
-function findClassesOldBehavior() {
-  var classes = [];
-  for (let directory of directoriesToSearch) {
-    readdirSync(directory).forEach(file => {
-      if (file.endsWith(".classes.ts")) {
-        const result = require(`${directory}/${file}`);
-        if (!(result?.default?.length ?? 0)) return;
-        console.log("Generated", result.default.length, "classes from", file);
-        for (let { name } of result.default) {
-          console.log(`  - ${name}`);
-        }
+const files = process.argv.slice(2);
+const outBase = files.pop();
 
-        classes.push(...result.default);
-      }
-    });
+const classes = [];
+for (const file of files) {
+  const result = require(file);
+  if (!(result?.default?.length ?? 0)) continue;
+  console.log("Found", result.default.length, "classes from", file);
+  for (let { name } of result.default) {
+    console.log(`  - ${name}`);
   }
-  classes.sort((a, b) => (a.name < b.name ? -1 : 1));
-  return classes;
-}
-
-function findClasses(argv: string[]) {
-  const classes = [];
-  for (const file of argv) {
-    const result = require(file);
-    if (!(result?.default?.length ?? 0)) continue;
-    console.log("Found", result.default.length, "classes from", file);
-    for (let { name } of result.default) {
-      console.log(`  - ${name}`);
-    }
 
-    classes.push(...result.default);
-  }
-  classes.sort((a, b) => (a.name < b.name ? -1 : 1));
-  return classes;
+  classes.push(...result.default);
 }
-
-const classes = process.argv.length > 2 ? findClasses(process.argv.slice(2)) : findClassesOldBehavior();
+classes.sort((a, b) => (a.name < b.name ? -1 : 1));
 
 function writeAndUnlink(path, content) {
   try {
@@ -1814,9 +1791,7 @@ function writeCppSerializers() {
   return output;
 }
 
-const bindingDir = `${import.meta.dir}/../bun.js/bindings`;
-
-await writeAndUnlink(`${bindingDir}/generated_classes.zig`, [
+await writeAndUnlink(`${outBase}/ZigGeneratedClasses.zig`, [
   ZIG_GENERATED_CLASSES_HEADER,
 
   ...classes.map(a => generateZig(a.name, a).trim()).join("\n"),
@@ -1825,30 +1800,30 @@ await writeAndUnlink(`${bindingDir}/generated_classes.zig`, [
 comptime {
   ${classes.map(a => `_ = ${className(a.name)};`).join("\n  ")}
 }
-  
+
   `,
 ]);
 const allHeaders = classes.map(a => generateHeader(a.name, a));
-await writeAndUnlink(`${bindingDir}/ZigGeneratedClasses.h`, [
+await writeAndUnlink(`${outBase}/ZigGeneratedClasses.h`, [
   GENERATED_CLASSES_HEADER[0],
   ...[...new Set(extraIncludes.map(a => `#include "${a}";` + "\n"))],
   GENERATED_CLASSES_HEADER[1],
   ...allHeaders,
   GENERATED_CLASSES_FOOTER,
 ]);
-await writeAndUnlink(`${bindingDir}/ZigGeneratedClasses.cpp`, [
+await writeAndUnlink(`${outBase}/ZigGeneratedClasses.cpp`, [
   GENERATED_CLASSES_IMPL_HEADER,
   ...classes.map(a => generateImpl(a.name, a)),
   writeCppSerializers(classes),
   GENERATED_CLASSES_IMPL_FOOTER,
 ]);
 await writeAndUnlink(
-  `${bindingDir}/ZigGeneratedClasses+lazyStructureHeader.h`,
+  `${outBase}/ZigGeneratedClasses+lazyStructureHeader.h`,
   classes.map(a => generateLazyClassStructureHeader(a.name, a)).join("\n"),
 );
 
 await writeAndUnlink(
-  `${bindingDir}/ZigGeneratedClasses+DOMClientIsoSubspaces.h`,
+  `${outBase}/ZigGeneratedClasses+DOMClientIsoSubspaces.h`,
   classes.map(a =>
     [
       `std::unique_ptr<GCClient::IsoSubspace> ${clientSubspaceFor(a.name)};`,
@@ -1858,7 +1833,7 @@ await writeAndUnlink(
 );
 
 await writeAndUnlink(
-  `${bindingDir}/ZigGeneratedClasses+DOMIsoSubspaces.h`,
+  `${outBase}/ZigGeneratedClasses+DOMIsoSubspaces.h`,
   classes.map(a =>
     [
       `std::unique_ptr<IsoSubspace> ${subspaceFor(a.name)};`,
@@ -1868,7 +1843,7 @@ await writeAndUnlink(
 );
 
 await writeAndUnlink(
-  `${bindingDir}/ZigGeneratedClasses+lazyStructureImpl.h`,
+  `${outBase}/ZigGeneratedClasses+lazyStructureImpl.h`,
   initLazyClasses(classes.map(a => generateLazyClassStructureImpl(a.name, a))) + "\n" + visitLazyClasses(classes),
 );
 
diff --git a/src/codegen/generate-jssink.ts b/src/codegen/generate-jssink.ts
index 292a740f8..8774105d2 100644
--- a/src/codegen/generate-jssink.ts
+++ b/src/codegen/generate-jssink.ts
@@ -1,4 +1,4 @@
-import { resolve } from "path";
+import { resolve, join } from "path";
 
 const classes = ["ArrayBufferSink", "FileSink", "HTTPResponseSink", "HTTPSResponseSink"];
 
@@ -14,6 +14,7 @@ function names(name) {
     writableStreamName: `JSWritableStreamSource${name}`,
   };
 }
+
 function header() {
   function classTemplate(name) {
     const { constructor, className, controller, writableStreamName } = names(name);
@@ -950,5 +951,14 @@ extern "C" void ${name}__onClose(JSC__JSValue controllerValue, JSC__JSValue reas
   return templ;
 }
 
-await Bun.write(resolve(import.meta.dir + "/../bun.js/bindings/JSSink.h"), header());
-await Bun.write(resolve(import.meta.dir + "/../bun.js/bindings/JSSink.cpp"), await implementation());
+const outDir = resolve(process.argv[2]);
+
+await Bun.write(resolve(outDir + "/JSSink.h"), header());
+await Bun.write(resolve(outDir + "/JSSink.cpp"), await implementation());
+
+Bun.spawnSync([
+  process.execPath,
+  join(import.meta.dir, "create-hash-table.ts"),
+  resolve(outDir + "/JSSink.cpp"),
+  outDir,
+]);
diff --git a/src/jsc.zig b/src/jsc.zig
index 5cdf739b3..bd868ee80 100644
--- a/src/jsc.zig
+++ b/src/jsc.zig
@@ -85,4 +85,6 @@ pub const Subprocess = @import("./bun.js/api/bun.zig").Subprocess;
 ///        - pub usingnamespace JSC.Codegen.JSMyClassName;
 ///  5. make clean-bindings && make bindings -j10
 ///
-pub const Codegen = @import("./bun.js/bindings/generated_classes.zig");
+pub const Codegen = @import("generated-classes");
+
+pub const GeneratedClassesList = @import("./bun.js/bindings/generated_classes_list.zig").Classes;