diff --git a/deps/ada/ada.cpp b/deps/ada/ada.cpp
index bff36abb835760..28ca61f8b801ab 100644
--- a/deps/ada/ada.cpp
+++ b/deps/ada/ada.cpp
@@ -1,4 +1,4 @@
-/* auto-generated on 2024-04-11 16:39:11 -0400. Do not edit! */
+/* auto-generated on 2024-05-30 22:24:57 -0400. Do not edit! */
 /* begin file src/ada.cpp */
 #include "ada.h"
 /* begin file src/checkers.cpp */
@@ -65,8 +65,7 @@ static constexpr std::array<uint8_t, 256> path_signature_table =
       std::array<uint8_t, 256> result{};
       for (size_t i = 0; i < 256; i++) {
         if (i <= 0x20 || i == 0x22 || i == 0x23 || i == 0x3c || i == 0x3e ||
-            i == 0x3f || i == 0x60 || i == 0x7b || i == 0x7b || i == 0x7d ||
-            i > 0x7e) {
+            i == 0x3f || i == 0x60 || i == 0x7b || i == 0x7d || i > 0x7e) {
           result[i] = 1;
         } else if (i == 0x25) {
           result[i] = 8;
@@ -9839,24 +9838,34 @@ ada_really_inline bool has_tabs_or_newline(
   }
   // fast path for long strings (expected to be common)
   size_t i = 0;
-  const uint8x16_t mask1 = vmovq_n_u8('\r');
-  const uint8x16_t mask2 = vmovq_n_u8('\n');
-  const uint8x16_t mask3 = vmovq_n_u8('\t');
+  /**
+   * The fastest way to check for `\t` (==9), '\n'(== 10) and `\r` (==13) relies
+   * on table lookup instruction. We notice that these are all unique numbers
+   * between 0..15. Let's prepare a special register, where we put '\t' in the
+   * 9th position, '\n' - 10th and '\r' - 13th. Then we shuffle this register by
+   * input register. If the input had `\t` in position X then this shuffled
+   * register will also have '\t' in that position. Comparing input with this
+   * shuffled register will mark us all interesting characters in the input.
+   *
+   * credit for algorithmic idea: @aqrit, credit for description:
+   * @DenisYaroshevskiy
+   */
+  static uint8_t rnt_array[16] = {1, 0, 0,  0, 0, 0,  0, 0,
+                                  0, 9, 10, 0, 0, 13, 0, 0};
+  const uint8x16_t rnt = vld1q_u8(rnt_array);
+  // m['0xd', '0xa', '0x9']
   uint8x16_t running{0};
   for (; i + 15 < user_input.size(); i += 16) {
     uint8x16_t word = vld1q_u8((const uint8_t*)user_input.data() + i);
-    running = vorrq_u8(vorrq_u8(running, vorrq_u8(vceqq_u8(word, mask1),
-                                                  vceqq_u8(word, mask2))),
-                       vceqq_u8(word, mask3));
+
+    running = vorrq_u8(running, vceqq_u8(vqtbl1q_u8(rnt, word), word));
   }
   if (i < user_input.size()) {
     uint8x16_t word =
         vld1q_u8((const uint8_t*)user_input.data() + user_input.length() - 16);
-    running = vorrq_u8(vorrq_u8(running, vorrq_u8(vceqq_u8(word, mask1),
-                                                  vceqq_u8(word, mask2))),
-                       vceqq_u8(word, mask3));
+    running = vorrq_u8(running, vceqq_u8(vqtbl1q_u8(rnt, word), word));
   }
-  return vmaxvq_u8(running) != 0;
+  return vmaxvq_u32(vreinterpretq_u32_u8(running)) != 0;
 }
 #elif ADA_SSE2
 ada_really_inline bool has_tabs_or_newline(
@@ -9876,6 +9885,7 @@ ada_really_inline bool has_tabs_or_newline(
   const __m128i mask1 = _mm_set1_epi8('\r');
   const __m128i mask2 = _mm_set1_epi8('\n');
   const __m128i mask3 = _mm_set1_epi8('\t');
+  // If we supported SSSE3, we could use the algorithm that we use for NEON.
   __m128i running{0};
   for (; i + 15 < user_input.size(); i += 16) {
     __m128i word = _mm_loadu_si128((const __m128i*)(user_input.data() + i));
@@ -9898,7 +9908,7 @@ ada_really_inline bool has_tabs_or_newline(
 ada_really_inline bool has_tabs_or_newline(
     std::string_view user_input) noexcept {
   auto has_zero_byte = [](uint64_t v) {
-    return ((v - 0x0101010101010101) & ~(v)&0x8080808080808080);
+    return ((v - 0x0101010101010101) & ~(v) & 0x8080808080808080);
   };
   size_t i = 0;
   uint64_t mask1 = broadcast('\r');
@@ -10028,15 +10038,8 @@ contains_forbidden_domain_code_point_or_upper(const char* input,
 constexpr static std::array<bool, 256> is_alnum_plus_table = []() constexpr {
   std::array<bool, 256> result{};
   for (size_t c = 0; c < 256; c++) {
-    if (c >= '0' && c <= '9') {
-      result[c] = true;
-    } else if (c >= 'a' && c <= 'z') {
-      result[c] = true;
-    } else if (c >= 'A' && c <= 'Z') {
-      result[c] = true;
-    } else if (c == '+' || c == '-' || c == '.') {
-      result[c] = true;
-    }
+    result[c] = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
+                (c >= 'A' && c <= 'Z') || c == '+' || c == '-' || c == '.';
   }
   return result;
 }();
@@ -10659,7 +10662,7 @@ ada_really_inline size_t find_next_host_delimiter_special(
     uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
     uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
     uint8x16_t classify = vandq_u8(lowpart, highpart);
-    if (vmaxvq_u8(classify) != 0) {
+    if (vmaxvq_u32(vreinterpretq_u32_u8(classify)) != 0) {
       uint8x16_t is_zero = vceqq_u8(classify, zero);
       uint16_t is_non_zero = ~to_bitmask(is_zero);
       return i + trailing_zeroes(is_non_zero);
@@ -10672,7 +10675,7 @@ ada_really_inline size_t find_next_host_delimiter_special(
     uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
     uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
     uint8x16_t classify = vandq_u8(lowpart, highpart);
-    if (vmaxvq_u8(classify) != 0) {
+    if (vmaxvq_u32(vreinterpretq_u32_u8(classify)) != 0) {
       uint8x16_t is_zero = vceqq_u8(classify, zero);
       uint16_t is_non_zero = ~to_bitmask(is_zero);
       return view.length() - 16 + trailing_zeroes(is_non_zero);
@@ -10797,7 +10800,7 @@ ada_really_inline size_t find_next_host_delimiter(std::string_view view,
     uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
     uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
     uint8x16_t classify = vandq_u8(lowpart, highpart);
-    if (vmaxvq_u8(classify) != 0) {
+    if (vmaxvq_u32(vreinterpretq_u32_u8(classify)) != 0) {
       uint8x16_t is_zero = vceqq_u8(classify, zero);
       uint16_t is_non_zero = ~to_bitmask(is_zero);
       return i + trailing_zeroes(is_non_zero);
@@ -10810,7 +10813,7 @@ ada_really_inline size_t find_next_host_delimiter(std::string_view view,
     uint8x16_t lowpart = vqtbl1q_u8(low_mask, vandq_u8(word, fmask));
     uint8x16_t highpart = vqtbl1q_u8(high_mask, vshrq_n_u8(word, 4));
     uint8x16_t classify = vandq_u8(lowpart, highpart);
-    if (vmaxvq_u8(classify) != 0) {
+    if (vmaxvq_u32(vreinterpretq_u32_u8(classify)) != 0) {
       uint8x16_t is_zero = vceqq_u8(classify, zero);
       uint16_t is_non_zero = ~to_bitmask(is_zero);
       return view.length() - 16 + trailing_zeroes(is_non_zero);
@@ -11164,7 +11167,7 @@ ada_really_inline void strip_trailing_spaces_from_opaque_path(
 static constexpr std::array<uint8_t, 256> authority_delimiter_special =
     []() constexpr {
       std::array<uint8_t, 256> result{};
-      for (int i : {'@', '/', '\\', '?'}) {
+      for (uint8_t i : {'@', '/', '\\', '?'}) {
         result[i] = 1;
       }
       return result;
@@ -11185,7 +11188,7 @@ find_authority_delimiter_special(std::string_view view) noexcept {
 // @ / ?
 static constexpr std::array<uint8_t, 256> authority_delimiter = []() constexpr {
   std::array<uint8_t, 256> result{};
-  for (int i : {'@', '/', '?'}) {
+  for (uint8_t i : {'@', '/', '?'}) {
     result[i] = 1;
   }
   return result;
@@ -11255,7 +11258,7 @@ bool url::parse_ipv4(std::string_view input) {
       segment_result = 0;
       input.remove_prefix(2);
     } else {
-      std::from_chars_result r;
+      std::from_chars_result r{};
       if (is_hex) {
         r = std::from_chars(input.data() + 2, input.data() + input.size(),
                             segment_result, 16);
@@ -11809,7 +11812,6 @@ ada_really_inline void url::parse_path(std::string_view input) {
  * Includes all the getters of `ada::url`
  */
 
-#include <algorithm>
 #include <string>
 
 namespace ada {
@@ -12058,7 +12060,6 @@ void url::set_hash(const std::string_view input) {
   helpers::remove_ascii_tab_or_newline(new_value);
   hash = unicode::percent_encode(new_value,
                                  ada::character_sets::FRAGMENT_PERCENT_ENCODE);
-  return;
 }
 
 void url::set_search(const std::string_view input) {
@@ -12136,7 +12137,6 @@ bool url::set_href(const std::string_view input) {
 /* end file src/url-setters.cpp */
 /* begin file src/parser.cpp */
 
-#include <numeric>
 #include <limits>
 
 namespace ada::parser {
@@ -13121,7 +13121,6 @@ namespace ada {
     if (hash_start < index) {
       return false;
     }
-    index = hash_start;
   }
 
   return true;
@@ -13479,7 +13478,7 @@ bool url_aggregator::set_pathname(const std::string_view input) {
   }
   clear_pathname();
   parse_path(input);
-  if (checkers::begins_with(input, "//") && !has_authority() &&
+  if (checkers::begins_with(get_pathname(), "//") && !has_authority() &&
       !has_dash_dot()) {
     buffer.insert(components.pathname_start, "/.");
     components.pathname_start += 2;
@@ -13863,7 +13862,7 @@ bool url_aggregator::set_hostname(const std::string_view input) {
   // if we have an empty host, then the space between components.host_end and
   // components.pathname_start may be occupied by /.
   if (start == components.host_end) {
-    return std::string_view();
+    return {};
   }
   return helpers::substring(buffer, start, components.pathname_start);
 }
@@ -13887,7 +13886,7 @@ bool url_aggregator::set_hostname(const std::string_view input) {
           components.pathname_start, " buffer.size() = ", buffer.size(),
           " components.search_start = ", components.search_start,
           " components.hash_start = ", components.hash_start);
-  uint32_t ending_index = uint32_t(buffer.size());
+  auto ending_index = uint32_t(buffer.size());
   if (components.search_start != url_components::omitted) {
     ending_index = components.search_start;
   } else if (components.hash_start != url_components::omitted) {
@@ -13903,7 +13902,7 @@ bool url_aggregator::set_hostname(const std::string_view input) {
   if (components.search_start == url_components::omitted) {
     return "";
   }
-  uint32_t ending_index = uint32_t(buffer.size());
+  auto ending_index = uint32_t(buffer.size());
   if (components.hash_start != url_components::omitted) {
     ending_index = components.hash_start;
   }
@@ -14041,7 +14040,7 @@ bool url_aggregator::parse_ipv4(std::string_view input, bool in_place) {
       segment_result = 0;
       input.remove_prefix(2);
     } else {
-      std::from_chars_result r;
+      std::from_chars_result r{};
       if (is_hex) {
         ada_log("parse_ipv4 trying to parse hex number");
         r = std::from_chars(input.data() + 2, input.data() + input.size(),
@@ -14988,8 +14987,7 @@ bool ada_can_parse_with_base(const char* input, size_t input_length,
 }
 
 void ada_free(ada_url result) noexcept {
-  ada::result<ada::url_aggregator>* r =
-      (ada::result<ada::url_aggregator>*)result;
+  auto* r = (ada::result<ada::url_aggregator>*)result;
   delete r;
 }
 
@@ -15006,7 +15004,7 @@ bool ada_is_valid(ada_url result) noexcept {
 // caller must free the result with ada_free_owned_string
 ada_owned_string ada_get_origin(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
-  ada_owned_string owned;
+  ada_owned_string owned{};
   if (!r) {
     owned.data = nullptr;
     owned.length = 0;
@@ -15021,14 +15019,12 @@ ada_owned_string ada_get_origin(ada_url result) noexcept {
 
 void ada_free_owned_string(ada_owned_string owned) noexcept {
   delete[] owned.data;
-  owned.data = nullptr;
-  owned.length = 0;
 }
 
 ada_string ada_get_href(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_href();
   return ada_string_create(out.data(), out.length());
@@ -15037,7 +15033,7 @@ ada_string ada_get_href(ada_url result) noexcept {
 ada_string ada_get_username(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_username();
   return ada_string_create(out.data(), out.length());
@@ -15046,7 +15042,7 @@ ada_string ada_get_username(ada_url result) noexcept {
 ada_string ada_get_password(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_password();
   return ada_string_create(out.data(), out.length());
@@ -15055,7 +15051,7 @@ ada_string ada_get_password(ada_url result) noexcept {
 ada_string ada_get_port(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_port();
   return ada_string_create(out.data(), out.length());
@@ -15064,7 +15060,7 @@ ada_string ada_get_port(ada_url result) noexcept {
 ada_string ada_get_hash(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_hash();
   return ada_string_create(out.data(), out.length());
@@ -15073,7 +15069,7 @@ ada_string ada_get_hash(ada_url result) noexcept {
 ada_string ada_get_host(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_host();
   return ada_string_create(out.data(), out.length());
@@ -15082,7 +15078,7 @@ ada_string ada_get_host(ada_url result) noexcept {
 ada_string ada_get_hostname(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_hostname();
   return ada_string_create(out.data(), out.length());
@@ -15091,7 +15087,7 @@ ada_string ada_get_hostname(ada_url result) noexcept {
 ada_string ada_get_pathname(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_pathname();
   return ada_string_create(out.data(), out.length());
@@ -15100,7 +15096,7 @@ ada_string ada_get_pathname(ada_url result) noexcept {
 ada_string ada_get_search(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_search();
   return ada_string_create(out.data(), out.length());
@@ -15109,7 +15105,7 @@ ada_string ada_get_search(ada_url result) noexcept {
 ada_string ada_get_protocol(ada_url result) noexcept {
   ada::result<ada::url_aggregator>& r = get_instance(result);
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view out = r->get_protocol();
   return ada_string_create(out.data(), out.length());
@@ -15368,15 +15364,14 @@ ada_url_search_params ada_parse_search_params(const char* input,
 }
 
 void ada_free_search_params(ada_url_search_params result) {
-  ada::result<ada::url_search_params>* r =
-      (ada::result<ada::url_search_params>*)result;
+  auto* r = (ada::result<ada::url_search_params>*)result;
   delete r;
 }
 
 ada_owned_string ada_search_params_to_string(ada_url_search_params result) {
   ada::result<ada::url_search_params>& r =
       *(ada::result<ada::url_search_params>*)result;
-  if (!r) return ada_owned_string{NULL, 0};
+  if (!r) return ada_owned_string{nullptr, 0};
   std::string out = r->to_string();
   ada_owned_string owned{};
   owned.length = out.size();
@@ -15471,11 +15466,11 @@ ada_string ada_search_params_get(ada_url_search_params result, const char* key,
   ada::result<ada::url_search_params>& r =
       *(ada::result<ada::url_search_params>*)result;
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   auto found = r->get(std::string_view(key, key_length));
   if (!found.has_value()) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   return ada_string_create(found->data(), found->length());
 }
@@ -15526,14 +15521,12 @@ ada_url_search_params_entries_iter ada_search_params_get_entries(
 }
 
 void ada_free_strings(ada_strings result) {
-  ada::result<std::vector<std::string>>* r =
-      (ada::result<std::vector<std::string>>*)result;
+  auto* r = (ada::result<std::vector<std::string>>*)result;
   delete r;
 }
 
 size_t ada_strings_size(ada_strings result) {
-  ada::result<std::vector<std::string>>* r =
-      (ada::result<std::vector<std::string>>*)result;
+  auto* r = (ada::result<std::vector<std::string>>*)result;
   if (!r) {
     return 0;
   }
@@ -15541,39 +15534,35 @@ size_t ada_strings_size(ada_strings result) {
 }
 
 ada_string ada_strings_get(ada_strings result, size_t index) {
-  ada::result<std::vector<std::string>>* r =
-      (ada::result<std::vector<std::string>>*)result;
+  auto* r = (ada::result<std::vector<std::string>>*)result;
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   std::string_view view = (*r)->at(index);
   return ada_string_create(view.data(), view.length());
 }
 
 void ada_free_search_params_keys_iter(ada_url_search_params_keys_iter result) {
-  ada::result<ada::url_search_params_keys_iter>* r =
-      (ada::result<ada::url_search_params_keys_iter>*)result;
+  auto* r = (ada::result<ada::url_search_params_keys_iter>*)result;
   delete r;
 }
 
 ada_string ada_search_params_keys_iter_next(
     ada_url_search_params_keys_iter result) {
-  ada::result<ada::url_search_params_keys_iter>* r =
-      (ada::result<ada::url_search_params_keys_iter>*)result;
+  auto* r = (ada::result<ada::url_search_params_keys_iter>*)result;
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   auto next = (*r)->next();
   if (!next.has_value()) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   return ada_string_create(next->data(), next->length());
 }
 
 bool ada_search_params_keys_iter_has_next(
     ada_url_search_params_keys_iter result) {
-  ada::result<ada::url_search_params_keys_iter>* r =
-      (ada::result<ada::url_search_params_keys_iter>*)result;
+  auto* r = (ada::result<ada::url_search_params_keys_iter>*)result;
   if (!r) {
     return false;
   }
@@ -15582,29 +15571,26 @@ bool ada_search_params_keys_iter_has_next(
 
 void ada_free_search_params_values_iter(
     ada_url_search_params_values_iter result) {
-  ada::result<ada::url_search_params_values_iter>* r =
-      (ada::result<ada::url_search_params_values_iter>*)result;
+  auto* r = (ada::result<ada::url_search_params_values_iter>*)result;
   delete r;
 }
 
 ada_string ada_search_params_values_iter_next(
     ada_url_search_params_values_iter result) {
-  ada::result<ada::url_search_params_values_iter>* r =
-      (ada::result<ada::url_search_params_values_iter>*)result;
+  auto* r = (ada::result<ada::url_search_params_values_iter>*)result;
   if (!r) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   auto next = (*r)->next();
   if (!next.has_value()) {
-    return ada_string_create(NULL, 0);
+    return ada_string_create(nullptr, 0);
   }
   return ada_string_create(next->data(), next->length());
 }
 
 bool ada_search_params_values_iter_has_next(
     ada_url_search_params_values_iter result) {
-  ada::result<ada::url_search_params_values_iter>* r =
-      (ada::result<ada::url_search_params_values_iter>*)result;
+  auto* r = (ada::result<ada::url_search_params_values_iter>*)result;
   if (!r) {
     return false;
   }
@@ -15613,19 +15599,17 @@ bool ada_search_params_values_iter_has_next(
 
 void ada_free_search_params_entries_iter(
     ada_url_search_params_entries_iter result) {
-  ada::result<ada::url_search_params_entries_iter>* r =
-      (ada::result<ada::url_search_params_entries_iter>*)result;
+  auto* r = (ada::result<ada::url_search_params_entries_iter>*)result;
   delete r;
 }
 
 ada_string_pair ada_search_params_entries_iter_next(
     ada_url_search_params_entries_iter result) {
-  ada::result<ada::url_search_params_entries_iter>* r =
-      (ada::result<ada::url_search_params_entries_iter>*)result;
-  if (!r) return {ada_string_create(NULL, 0), ada_string_create(NULL, 0)};
+  auto* r = (ada::result<ada::url_search_params_entries_iter>*)result;
+  if (!r) return {ada_string_create(nullptr, 0), ada_string_create(nullptr, 0)};
   auto next = (*r)->next();
   if (!next.has_value()) {
-    return {ada_string_create(NULL, 0), ada_string_create(NULL, 0)};
+    return {ada_string_create(nullptr, 0), ada_string_create(nullptr, 0)};
   }
   return ada_string_pair{
       ada_string_create(next->first.data(), next->first.length()),
@@ -15634,8 +15618,7 @@ ada_string_pair ada_search_params_entries_iter_next(
 
 bool ada_search_params_entries_iter_has_next(
     ada_url_search_params_entries_iter result) {
-  ada::result<ada::url_search_params_entries_iter>* r =
-      (ada::result<ada::url_search_params_entries_iter>*)result;
+  auto* r = (ada::result<ada::url_search_params_entries_iter>*)result;
   if (!r) {
     return false;
   }
diff --git a/deps/ada/ada.h b/deps/ada/ada.h
index b9e000b841d1ed..9142fbf66c8488 100644
--- a/deps/ada/ada.h
+++ b/deps/ada/ada.h
@@ -1,4 +1,4 @@
-/* auto-generated on 2024-04-11 16:39:11 -0400. Do not edit! */
+/* auto-generated on 2024-05-30 22:24:57 -0400. Do not edit! */
 /* begin file include/ada.h */
 /**
  * @file ada.h
@@ -1214,25 +1214,104 @@ namespace ada {
  * @see https://url.spec.whatwg.org/#url-parsing
  */
 enum class state {
+  /**
+   * @see https://url.spec.whatwg.org/#authority-state
+   */
   AUTHORITY,
+
+  /**
+   * @see https://url.spec.whatwg.org/#scheme-start-state
+   */
   SCHEME_START,
+
+  /**
+   * @see https://url.spec.whatwg.org/#scheme-state
+   */
   SCHEME,
+
+  /**
+   * @see https://url.spec.whatwg.org/#host-state
+   */
   HOST,
+
+  /**
+   * @see https://url.spec.whatwg.org/#no-scheme-state
+   */
   NO_SCHEME,
+
+  /**
+   * @see https://url.spec.whatwg.org/#fragment-state
+   */
   FRAGMENT,
+
+  /**
+   * @see https://url.spec.whatwg.org/#relative-state
+   */
   RELATIVE_SCHEME,
+
+  /**
+   * @see https://url.spec.whatwg.org/#relative-slash-state
+   */
   RELATIVE_SLASH,
+
+  /**
+   * @see https://url.spec.whatwg.org/#file-state
+   */
   FILE,
+
+  /**
+   * @see https://url.spec.whatwg.org/#file-host-state
+   */
   FILE_HOST,
+
+  /**
+   * @see https://url.spec.whatwg.org/#file-slash-state
+   */
   FILE_SLASH,
+
+  /**
+   * @see https://url.spec.whatwg.org/#path-or-authority-state
+   */
   PATH_OR_AUTHORITY,
+
+  /**
+   * @see https://url.spec.whatwg.org/#special-authority-ignore-slashes-state
+   */
   SPECIAL_AUTHORITY_IGNORE_SLASHES,
+
+  /**
+   * @see https://url.spec.whatwg.org/#special-authority-slashes-state
+   */
   SPECIAL_AUTHORITY_SLASHES,
+
+  /**
+   * @see https://url.spec.whatwg.org/#special-relative-or-authority-state
+   */
   SPECIAL_RELATIVE_OR_AUTHORITY,
+
+  /**
+   * @see https://url.spec.whatwg.org/#query-state
+   */
   QUERY,
+
+  /**
+   * @see https://url.spec.whatwg.org/#path-state
+   */
   PATH,
+
+  /**
+   * @see https://url.spec.whatwg.org/#path-start-state
+   */
   PATH_START,
+
+  /**
+   * @see https://url.spec.whatwg.org/#cannot-be-a-base-url-path-state
+   */
   OPAQUE_PATH,
+
+  /**
+   * @see https://url.spec.whatwg.org/#port-state
+   */
   PORT,
 };
 
@@ -2753,8 +2832,9 @@ struct expected_operations_base<void, E> : expected_storage_base<void, E> {
 // This class manages conditionally having a trivial copy constructor
 // This specialization is for when T and E are trivially copy constructible
 template <class T, class E,
-          bool = is_void_or<T, TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>::
-              value &&TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value>
+          bool = is_void_or<T, TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(
+                                   T)>::value &&
+                 TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value>
 struct expected_copy_base : expected_operations_base<T, E> {
   using expected_operations_base<T, E>::expected_operations_base;
 };
@@ -2786,8 +2866,9 @@ struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
 // move constructible
 #ifndef TL_EXPECTED_GCC49
 template <class T, class E,
-          bool = is_void_or<T, std::is_trivially_move_constructible<T>>::value
-              &&std::is_trivially_move_constructible<E>::value>
+          bool =
+              is_void_or<T, std::is_trivially_move_constructible<T>>::value &&
+              std::is_trivially_move_constructible<E>::value>
 struct expected_move_base : expected_copy_base<T, E> {
   using expected_copy_base<T, E>::expected_copy_base;
 };
@@ -2816,14 +2897,16 @@ struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
 };
 
 // This class manages conditionally having a trivial copy assignment operator
-template <class T, class E,
-          bool = is_void_or<
-              T, conjunction<TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T),
-                             TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T),
-                             TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value
-              &&TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value
-                  &&TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value
-                      &&TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value>
+template <
+    class T, class E,
+    bool =
+        is_void_or<
+            T, conjunction<TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T),
+                           TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T),
+                           TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value &&
+        TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value &&
+        TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value &&
+        TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value>
 struct expected_copy_assign_base : expected_move_base<T, E> {
   using expected_move_base<T, E>::expected_move_base;
 };
@@ -2850,14 +2933,15 @@ struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
 // to make do with a non-trivial move assignment operator even if T is trivially
 // move assignable
 #ifndef TL_EXPECTED_GCC49
-template <class T, class E,
-          bool =
-              is_void_or<T, conjunction<std::is_trivially_destructible<T>,
-                                        std::is_trivially_move_constructible<T>,
-                                        std::is_trivially_move_assignable<T>>>::
-                  value &&std::is_trivially_destructible<E>::value
-                      &&std::is_trivially_move_constructible<E>::value
-                          &&std::is_trivially_move_assignable<E>::value>
+template <
+    class T, class E,
+    bool = is_void_or<
+               T, conjunction<std::is_trivially_destructible<T>,
+                              std::is_trivially_move_constructible<T>,
+                              std::is_trivially_move_assignable<T>>>::value &&
+           std::is_trivially_destructible<E>::value &&
+           std::is_trivially_move_constructible<E>::value &&
+           std::is_trivially_move_assignable<E>::value>
 struct expected_move_assign_base : expected_copy_assign_base<T, E> {
   using expected_copy_assign_base<T, E>::expected_copy_assign_base;
 };
@@ -2879,10 +2963,10 @@ struct expected_move_assign_base<T, E, false>
   expected_move_assign_base &operator=(const expected_move_assign_base &rhs) =
       default;
 
-  expected_move_assign_base &
-  operator=(expected_move_assign_base &&rhs) noexcept(
-      std::is_nothrow_move_constructible<T>::value
-          &&std::is_nothrow_move_assignable<T>::value) {
+  expected_move_assign_base &operator=(
+      expected_move_assign_base
+          &&rhs) noexcept(std::is_nothrow_move_constructible<T>::value &&
+                          std::is_nothrow_move_assignable<T>::value) {
     this->assign(std::move(rhs));
     return *this;
   }
@@ -3771,11 +3855,10 @@ class expected : private detail::expected_move_assign_base<T, E>,
                       detail::is_swappable<OE>::value &&
                       (std::is_nothrow_move_constructible<OT>::value ||
                        std::is_nothrow_move_constructible<OE>::value)>
-  swap(expected &rhs) noexcept(
-      std::is_nothrow_move_constructible<T>::value
-          &&detail::is_nothrow_swappable<T>::value
-              &&std::is_nothrow_move_constructible<E>::value
-                  &&detail::is_nothrow_swappable<E>::value) {
+  swap(expected &rhs) noexcept(std::is_nothrow_move_constructible<T>::value &&
+                               detail::is_nothrow_swappable<T>::value &&
+                               std::is_nothrow_move_constructible<E>::value &&
+                               detail::is_nothrow_swappable<E>::value) {
     if (has_value() && rhs.has_value()) {
       swap_where_both_have_value(rhs, typename std::is_void<T>::type{});
     } else if (!has_value() && rhs.has_value()) {
@@ -4312,7 +4395,10 @@ struct url;
 namespace ada::parser {
 
 /**
- * Parses a url.
+ * Parses a url. The parameter user_input is the input to be parsed:
+ * it should be a valid UTF-8 string. The parameter base_url is an optional
+ * parameter that can be used to resolve relative URLs. If the base_url is
+ * provided, the user_input is resolved against the base_url.
  */
 template <typename result_type = ada::url_aggregator>
 result_type parse_url(std::string_view user_input,
@@ -7169,14 +7255,14 @@ url_search_params_entries_iter::next() {
 #ifndef ADA_ADA_VERSION_H
 #define ADA_ADA_VERSION_H
 
-#define ADA_VERSION "2.7.8"
+#define ADA_VERSION "2.8.0"
 
 namespace ada {
 
 enum {
   ADA_VERSION_MAJOR = 2,
-  ADA_VERSION_MINOR = 7,
-  ADA_VERSION_REVISION = 8,
+  ADA_VERSION_MINOR = 8,
+  ADA_VERSION_REVISION = 0,
 };
 
 }  // namespace ada