diff --git a/Userland/Libraries/LibWeb/HTML/HTMLInputElement.cpp b/Userland/Libraries/LibWeb/HTML/HTMLInputElement.cpp
index 7705f7ada86..5533fa20650 100644
--- a/Userland/Libraries/LibWeb/HTML/HTMLInputElement.cpp
+++ b/Userland/Libraries/LibWeb/HTML/HTMLInputElement.cpp
@@ -1166,11 +1166,9 @@ i32 HTMLInputElement::default_tab_index_value() const
 unsigned HTMLInputElement::size() const
 {
     // The size IDL attribute is limited to only positive numbers and has a default value of 20.
-    auto maybe_size_string = get_attribute(HTML::AttributeNames::size);
-    if (maybe_size_string.has_value()) {
-        auto maybe_size = parse_non_negative_integer(maybe_size_string.value());
-        if (maybe_size.has_value())
-            return maybe_size.value();
+    if (auto size_string = get_attribute(HTML::AttributeNames::size); size_string.has_value()) {
+        if (auto size = parse_non_negative_integer(*size_string); size.has_value())
+            return *size;
     }
     return 20;
 }
diff --git a/Userland/Libraries/LibWeb/HTML/HTMLMeterElement.cpp b/Userland/Libraries/LibWeb/HTML/HTMLMeterElement.cpp
index 873b29e9963..efae3276df4 100644
--- a/Userland/Libraries/LibWeb/HTML/HTMLMeterElement.cpp
+++ b/Userland/Libraries/LibWeb/HTML/HTMLMeterElement.cpp
@@ -38,11 +38,9 @@ double HTMLMeterElement::value() const
 {
     // If the value attribute is specified and a value could be parsed out of it, then that value is the candidate actual value. Otherwise, the candidate actual value is zero.
     double candidate_value = 0.0;
-    auto maybe_value_string = get_attribute(HTML::AttributeNames::value);
-    if (maybe_value_string.has_value()) {
-        auto maybe_value = parse_floating_point_number(maybe_value_string.value());
-        if (maybe_value.has_value())
-            candidate_value = maybe_value.value();
+    if (auto value_string = get_attribute(HTML::AttributeNames::value); value_string.has_value()) {
+        if (auto value = parse_floating_point_number(*value_string); value.has_value())
+            candidate_value = *value;
     }
 
     // If the candidate actual value is less than the minimum value, then the actual value is the minimum value.
@@ -63,11 +61,9 @@ WebIDL::ExceptionOr<void> HTMLMeterElement::set_value(double value)
 double HTMLMeterElement::min() const
 {
     // If the min attribute is specified and a value could be parsed out of it, then the minimum value is that value. Otherwise, the minimum value is zero.
-    auto maybe_min_string = get_attribute(HTML::AttributeNames::min);
-    if (maybe_min_string.has_value()) {
-        auto maybe_min = parse_floating_point_number(maybe_min_string.value());
-        if (maybe_min.has_value())
-            return maybe_min.value();
+    if (auto min_string = get_attribute(HTML::AttributeNames::min); min_string.has_value()) {
+        if (auto min = parse_floating_point_number(*min_string); min.has_value())
+            return *min;
     }
     return 0;
 }
@@ -85,11 +81,9 @@ double HTMLMeterElement::max() const
 {
     // If the max attribute is specified and a value could be parsed out of it, then the candidate maximum value is that value. Otherwise, the candidate maximum value is 1.0.
     double candidate_max = 1.0;
-    auto maybe_max_string = get_attribute(HTML::AttributeNames::max);
-    if (maybe_max_string.has_value()) {
-        auto maybe_max = parse_floating_point_number(maybe_max_string.value());
-        if (maybe_max.has_value())
-            candidate_max = maybe_max.value();
+    if (auto max_string = get_attribute(HTML::AttributeNames::max); max_string.has_value()) {
+        if (auto max = parse_floating_point_number(*max_string); max.has_value())
+            candidate_max = *max;
     }
 
     // If the candidate maximum value is greater than or equal to the minimum value, then the maximum value is the candidate maximum value. Otherwise, the maximum value is the same as the minimum value.
@@ -109,11 +103,9 @@ double HTMLMeterElement::low() const
 {
     // If the low attribute is specified and a value could be parsed out of it, then the candidate low boundary is that value. Otherwise, the candidate low boundary is the same as the minimum value.
     double candidate_low = min();
-    auto maybe_low_string = get_attribute(HTML::AttributeNames::low);
-    if (maybe_low_string.has_value()) {
-        auto maybe_low = parse_floating_point_number(maybe_low_string.value());
-        if (maybe_low.has_value())
-            candidate_low = maybe_low.value();
+    if (auto low_string = get_attribute(HTML::AttributeNames::low); low_string.has_value()) {
+        if (auto low = parse_floating_point_number(*low_string); low.has_value())
+            candidate_low = *low;
     }
 
     // If the candidate low boundary is less than the minimum value, then the low boundary is the minimum value.
@@ -135,11 +127,9 @@ double HTMLMeterElement::high() const
 {
     // If the high attribute is specified and a value could be parsed out of it, then the candidate high boundary is that value. Otherwise, the candidate high boundary is the same as the maximum value.
     double candidate_high = max();
-    auto maybe_high_string = get_attribute(HTML::AttributeNames::high);
-    if (maybe_high_string.has_value()) {
-        auto maybe_high = parse_floating_point_number(maybe_high_string.value());
-        if (maybe_high.has_value())
-            candidate_high = maybe_high.value();
+    if (auto high_string = get_attribute(HTML::AttributeNames::high); high_string.has_value()) {
+        if (auto high = parse_floating_point_number(*high_string); high.has_value())
+            candidate_high = *high;
     }
 
     // If the candidate high boundary is less than the low boundary, then the high boundary is the low boundary.
@@ -161,11 +151,9 @@ double HTMLMeterElement::optimum() const
 {
     // If the optimum attribute is specified and a value could be parsed out of it, then the candidate optimum point is that value. Otherwise, the candidate optimum point is the midpoint between the minimum value and the maximum value.
     double candidate_optimum = (max() + min()) / 2;
-    auto maybe_optimum_string = get_attribute(HTML::AttributeNames::optimum);
-    if (maybe_optimum_string.has_value()) {
-        auto maybe_optimum = parse_floating_point_number(maybe_optimum_string.value());
-        if (maybe_optimum.has_value())
-            candidate_optimum = maybe_optimum.value();
+    if (auto optimum_string = get_attribute(HTML::AttributeNames::optimum); optimum_string.has_value()) {
+        if (auto optimum = parse_floating_point_number(*optimum_string); optimum.has_value())
+            candidate_optimum = *optimum;
     }
 
     // If the candidate optimum point is less than the minimum value, then the optimum point is the minimum value.
@@ -246,5 +234,4 @@ void HTMLMeterElement::update_meter_value_element()
     double position = (value - min) / (max - min) * 100;
     MUST(m_meter_value_element->set_attribute(HTML::AttributeNames::style, MUST(String::formatted("width: {}%;", position))));
 }
-
 }
diff --git a/Userland/Libraries/LibWeb/HTML/HTMLProgressElement.cpp b/Userland/Libraries/LibWeb/HTML/HTMLProgressElement.cpp
index 6812aa1e6a8..3368460dbd7 100644
--- a/Userland/Libraries/LibWeb/HTML/HTMLProgressElement.cpp
+++ b/Userland/Libraries/LibWeb/HTML/HTMLProgressElement.cpp
@@ -37,13 +37,11 @@ void HTMLProgressElement::visit_edges(Cell::Visitor& visitor)
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-progress-value
 double HTMLProgressElement::value() const
 {
-    auto maybe_value_string = get_attribute(HTML::AttributeNames::value);
-    if (!maybe_value_string.has_value())
-        return 0;
-    auto maybe_value = parse_floating_point_number(maybe_value_string.value());
-    if (!maybe_value.has_value())
-        return 0;
-    return clamp(maybe_value.value(), 0, max());
+    if (auto value_string = get_attribute(HTML::AttributeNames::value); value_string.has_value()) {
+        if (auto value = parse_floating_point_number(*value_string); value.has_value())
+            return clamp(*value, 0, max());
+    }
+    return 0;
 }
 
 WebIDL::ExceptionOr<void> HTMLProgressElement::set_value(double value)
@@ -60,13 +58,11 @@ WebIDL::ExceptionOr<void> HTMLProgressElement::set_value(double value)
 // https://html.spec.whatwg.org/multipage/form-elements.html#dom-progress-max
 double HTMLProgressElement::max() const
 {
-    auto maybe_max_string = get_attribute(HTML::AttributeNames::max);
-    if (!maybe_max_string.has_value())
-        return 1;
-    auto maybe_max = parse_floating_point_number(maybe_max_string.value());
-    if (!maybe_max.has_value())
-        return 1;
-    return AK::max(maybe_max.value(), 0);
+    if (auto max_string = get_attribute(HTML::AttributeNames::max); max_string.has_value()) {
+        if (auto max = parse_floating_point_number(*max_string); max.has_value())
+            return AK::max(*max, 0);
+    }
+    return 1;
 }
 
 WebIDL::ExceptionOr<void> HTMLProgressElement::set_max(double value)
diff --git a/Userland/Libraries/LibWeb/HTML/HTMLTableColElement.cpp b/Userland/Libraries/LibWeb/HTML/HTMLTableColElement.cpp
index dd87b46ff0a..b8123c50cc1 100644
--- a/Userland/Libraries/LibWeb/HTML/HTMLTableColElement.cpp
+++ b/Userland/Libraries/LibWeb/HTML/HTMLTableColElement.cpp
@@ -29,11 +29,9 @@ void HTMLTableColElement::initialize(JS::Realm& realm)
 unsigned int HTMLTableColElement::span() const
 {
     // The span IDL attribute must reflect the content attribute of the same name. It is clamped to the range [1, 1000], and its default value is 1.
-    auto maybe_span_string = get_attribute(HTML::AttributeNames::span);
-    if (maybe_span_string.has_value()) {
-        auto maybe_span = parse_non_negative_integer(maybe_span_string.value());
-        if (maybe_span.has_value())
-            return clamp(maybe_span.value(), 1, 1000);
+    if (auto span_string = get_attribute(HTML::AttributeNames::span); span_string.has_value()) {
+        if (auto span = parse_non_negative_integer(*span_string); span.has_value())
+            return clamp(*span, 1, 1000);
     }
     return 1;
 }
diff --git a/Userland/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp b/Userland/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp
index 668a9d7ceed..6d107730fc9 100644
--- a/Userland/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp
+++ b/Userland/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp
@@ -100,11 +100,9 @@ void HTMLTextAreaElement::form_associated_element_was_removed(DOM::Node*)
 unsigned HTMLTextAreaElement::cols() const
 {
     // The cols and rows attributes are limited to only positive numbers with fallback. The cols IDL attribute's default value is 20.
-    auto maybe_cols_string = get_attribute(HTML::AttributeNames::cols);
-    if (maybe_cols_string.has_value()) {
-        auto maybe_cols = parse_non_negative_integer(maybe_cols_string.value());
-        if (maybe_cols.has_value())
-            return maybe_cols.value();
+    if (auto cols_string = get_attribute(HTML::AttributeNames::cols); cols_string.has_value()) {
+        if (auto cols = parse_non_negative_integer(*cols_string); cols.has_value())
+            return *cols;
     }
     return 20;
 }
@@ -118,11 +116,9 @@ WebIDL::ExceptionOr<void> HTMLTextAreaElement::set_cols(unsigned value)
 unsigned HTMLTextAreaElement::rows() const
 {
     // The cols and rows attributes are limited to only positive numbers with fallback. The rows IDL attribute's default value is 2.
-    auto maybe_rows_string = get_attribute(HTML::AttributeNames::rows);
-    if (maybe_rows_string.has_value()) {
-        auto maybe_rows = parse_non_negative_integer(maybe_rows_string.value());
-        if (maybe_rows.has_value())
-            return maybe_rows.value();
+    if (auto rows_string = get_attribute(HTML::AttributeNames::rows); rows_string.has_value()) {
+        if (auto rows = parse_non_negative_integer(*rows_string); rows.has_value())
+            return *rows;
     }
     return 2;
 }