diff --git a/include/argparse.hpp b/include/argparse.hpp
index 2c2124d..9a3878c 100644
--- a/include/argparse.hpp
+++ b/include/argparse.hpp
@@ -1406,7 +1406,21 @@ namespace argparse
                     auto get_consumable_args(auto it, std::ranges::view auto consumable) const
                     {
                         return std::ranges::subrange(std::ranges::next(it), consumable.end())
-                            | std::views::take_while([](auto const & token) { return !token.m_token.starts_with("-"); });
+                            | std::views::take_while([](auto const & token)
+                                {
+                                    if (!token.m_token.starts_with("-"))
+                                    {
+                                        return true;
+                                    }
+                                    auto iss = std::istringstream(token.m_token);
+                                    auto num = double();
+                                    iss >> num;
+                                    if (!iss.fail() && (iss.eof() || iss.peek() == std::istringstream::traits_type::eof()))
+                                    {
+                                        return true;
+                                    }
+                                    return false;
+                                });
                     }
 
                 private:
diff --git a/test/unittest/test_parsing_optional.cpp b/test/unittest/test_parsing_optional.cpp
index 4b6e0d1..19f40da 100644
--- a/test/unittest/test_parsing_optional.cpp
+++ b/test/unittest/test_parsing_optional.cpp
@@ -2809,82 +2809,154 @@ TEST_CASE("Parsing joined flags does not affect long options")
     CHECK(args.get_value<bool>("r") == true);
 }
 
-TEST_CASE("Parsing an optional argument yields correct value for positive number")
+TEST_CASE_TEMPLATE("Parsing an optional argument yields correct value for positive number", T, short int, unsigned short int, int, unsigned int, long int, unsigned long int, long long int, unsigned long long int, float, double, long double)
 {
     auto parser = argparse::ArgumentParser();
-    parser.add_argument("-n").type<int>();
+    parser.add_argument("-n").type<T>();
 
-    auto const args = parser.parse_args(3, cstr_arr{"prog", "-n", "65"});
+    if constexpr (std::is_integral_v<T>)
+    {
+        auto const args = parser.parse_args(3, cstr_arr{"prog", "-n", "65"});
 
-    CHECK(args.get_value<int>("n") == 65);
+        CHECK(args.get_value<T>("n") == T(65));
+    }
+    else
+    {
+        auto const args = parser.parse_args(3, cstr_arr{"prog", "-n", "1.125"});
+
+        CHECK(args.get_value<T>("n") == T(1.125));
+    }
 }
 
-TEST_CASE("Parsing an optional argument yields correct value for positive number")
+TEST_CASE_TEMPLATE("Parsing an optional argument yields correct value for positive number", T, short int, unsigned short int, int, unsigned int, long int, unsigned long int, long long int, unsigned long long int, float, double, long double)
 {
     auto parser = argparse::ArgumentParser();
-    parser.add_argument("-n").type<int>();
+    parser.add_argument("-n").type<T>();
 
-    auto const args = parser.parse_args(2, cstr_arr{"prog", "-n65"});
+    if constexpr (std::is_integral_v<T>)
+    {
+        auto const args = parser.parse_args(2, cstr_arr{"prog", "-n65"});
 
-    CHECK(args.get_value<int>("n") == 65);
+        CHECK(args.get_value<T>("n") == T(65));
+    }
+    else
+    {
+        auto const args = parser.parse_args(2, cstr_arr{"prog", "-n1.125"});
+
+        CHECK(args.get_value<T>("n") == T(1.125));
+    }
 }
 
-TEST_CASE("Parsing an optional argument yields correct value for positive number")
+TEST_CASE_TEMPLATE("Parsing an optional argument yields correct value for positive number", T, short int, unsigned short int, int, unsigned int, long int, unsigned long int, long long int, unsigned long long int, float, double, long double)
 {
     auto parser = argparse::ArgumentParser();
-    parser.add_argument("--number").type<int>();
+    parser.add_argument("--number").type<T>();
 
-    auto const args = parser.parse_args(3, cstr_arr{"prog", "--number", "65"});
+    if constexpr (std::is_integral_v<T>)
+    {
+        auto const args = parser.parse_args(3, cstr_arr{"prog", "--number", "65"});
 
-    CHECK(args.get_value<int>("number") == 65);
+        CHECK(args.get_value<T>("number") == T(65));
+    }
+    else
+    {
+        auto const args = parser.parse_args(3, cstr_arr{"prog", "--number", "1.125"});
+
+        CHECK(args.get_value<T>("number") == T(1.125));
+    }
 }
 
-TEST_CASE("Parsing an optional argument yields correct value for positive number")
+TEST_CASE_TEMPLATE("Parsing an optional argument yields correct value for positive number", T, short int, unsigned short int, int, unsigned int, long int, unsigned long int, long long int, unsigned long long int, float, double, long double)
 {
     auto parser = argparse::ArgumentParser();
-    parser.add_argument("--number").type<int>();
+    parser.add_argument("--number").type<T>();
 
-    auto const args = parser.parse_args(2, cstr_arr{"prog", "--number=65"});
+    if constexpr (std::is_integral_v<T>)
+    {
+        auto const args = parser.parse_args(2, cstr_arr{"prog", "--number=65"});
 
-    CHECK(args.get_value<int>("number") == 65);
+        CHECK(args.get_value<T>("number") == T(65));
+    }
+    else
+    {
+        auto const args = parser.parse_args(2, cstr_arr{"prog", "--number=1.125"});
+
+        CHECK(args.get_value<T>("number") == T(1.125));
+    }
 }
 
-TEST_CASE("Parsing an optional argument yields correct value for negative number" * doctest::skip())
+TEST_CASE_TEMPLATE("Parsing an optional argument yields correct value for negative number", T, short int, int, long int, long long int, float, double, long double)
 {
     auto parser = argparse::ArgumentParser();
-    parser.add_argument("-n").type<int>();
+    parser.add_argument("-n").type<T>();
 
-    auto const args = parser.parse_args(3, cstr_arr{"prog", "-n", "-65"});
+    if constexpr (std::is_integral_v<T>)
+    {
+        auto const args = parser.parse_args(3, cstr_arr{"prog", "-n", "-65"});
 
-    CHECK(args.get_value<int>("n") == -65);
+        CHECK(args.get_value<T>("n") == T(-65));
+    }
+    else
+    {
+        auto const args = parser.parse_args(3, cstr_arr{"prog", "-n", "-1.125"});
+
+        CHECK(args.get_value<T>("n") == T(-1.125));
+    }
 }
 
-TEST_CASE("Parsing an optional argument yields correct value for negative number")
+TEST_CASE_TEMPLATE("Parsing an optional argument yields correct value for negative number", T, short int, int, long int, long long int, float, double, long double)
 {
     auto parser = argparse::ArgumentParser();
-    parser.add_argument("-n").type<int>();
+    parser.add_argument("-n").type<T>();
 
-    auto const args = parser.parse_args(2, cstr_arr{"prog", "-n-65"});
+    if constexpr (std::is_integral_v<T>)
+    {
+        auto const args = parser.parse_args(2, cstr_arr{"prog", "-n-65"});
 
-    CHECK(args.get_value<int>("n") == -65);
+        CHECK(args.get_value<T>("n") == T(-65));
+    }
+    else
+    {
+        auto const args = parser.parse_args(2, cstr_arr{"prog", "-n-1.125"});
+
+        CHECK(args.get_value<T>("n") == T(-1.125));
+    }
 }
 
-TEST_CASE("Parsing an optional argument yields correct value for negative number" * doctest::skip())
+TEST_CASE_TEMPLATE("Parsing an optional argument yields correct value for negative number", T, short int, int, long int, long long int, float, double, long double)
 {
     auto parser = argparse::ArgumentParser();
-    parser.add_argument("--number").type<int>();
+    parser.add_argument("--number").type<T>();
 
-    auto const args = parser.parse_args(3, cstr_arr{"prog", "--number", "-65"});
+    if constexpr (std::is_integral_v<T>)
+    {
+        auto const args = parser.parse_args(3, cstr_arr{"prog", "--number", "-65"});
 
-    CHECK(args.get_value<int>("number") == -65);
+        CHECK(args.get_value<T>("number") == T(-65));
+    }
+    else
+    {
+        auto const args = parser.parse_args(3, cstr_arr{"prog", "--number", "-1.125"});
+
+        CHECK(args.get_value<T>("number") == T(-1.125));
+    }
 }
 
-TEST_CASE("Parsing an optional argument yields correct value for negative number")
+TEST_CASE_TEMPLATE("Parsing an optional argument yields correct value for negative number", T, short int, int, long int, long long int, float, double, long double)
 {
     auto parser = argparse::ArgumentParser();
-    parser.add_argument("--number").type<int>();
+    parser.add_argument("--number").type<T>();
 
-    auto const args = parser.parse_args(2, cstr_arr{"prog", "--number=-65"});
+    if constexpr (std::is_integral_v<T>)
+    {
+        auto const args = parser.parse_args(2, cstr_arr{"prog", "--number=-65"});
 
-    CHECK(args.get_value<int>("number") == -65);
+        CHECK(args.get_value<T>("number") == T(-65));
+    }
+    else
+    {
+        auto const args = parser.parse_args(2, cstr_arr{"prog", "--number=-1.125"});
+
+        CHECK(args.get_value<T>("number") == T(-1.125));
+    }
 }