diff --git a/include/quicr/namespace.h b/include/quicr/namespace.h
index 00616e0..c0072cd 100644
--- a/include/quicr/namespace.h
+++ b/include/quicr/namespace.h
@@ -5,26 +5,25 @@
 #include <map>
 #include <ostream>
 
-namespace quicr {
+namespace quicr
+{
 
 /**
  * @brief A prefix for a quicr::Name
  */
 class Namespace
 {
-    static constexpr Name mask(const Name& name, uint8_t sig_bits)
+    static constexpr Name mask(const Name &name, uint8_t sig_bits)
     {
         return name & ~(~0x0_name >> sig_bits);
     }
 
   public:
     Namespace() = default;
-    constexpr Namespace(const Namespace& ns) = default;
-    Namespace(Namespace&& ns) = default;
+    constexpr Namespace(const Namespace &ns) = default;
+    Namespace(Namespace &&ns) = default;
 
-    constexpr Namespace(Name name, uint8_t sig_bits)
-      : _name{ mask(name, sig_bits) }
-      , _sig_bits{ sig_bits }
+    constexpr Namespace(Name name, uint8_t sig_bits) : _name{mask(name, sig_bits)}, _sig_bits{sig_bits}
     {
     }
 
@@ -37,69 +36,75 @@ class Namespace
         _sig_bits = std::atoi(str.data());
     }
 
-    constexpr Namespace& operator=(const Namespace& other) = default;
-    Namespace& operator=(Namespace&& other) = default;
+    constexpr Namespace &operator=(const Namespace &other) = default;
+    Namespace &operator=(Namespace &&other) = default;
 
-    constexpr bool contains(const Name& name) const
+    constexpr bool contains(const Name &name) const
     {
         return mask(name, _sig_bits) == _name;
     }
 
-    constexpr bool contains(const Namespace& prefix) const
+    constexpr bool contains(const Namespace &prefix) const
     {
         return contains(prefix._name);
     }
 
-    constexpr Name name() const { return _name; }
+    constexpr Name name() const
+    {
+        return _name;
+    }
 
-    constexpr uint8_t length() const { return _sig_bits; }
+    constexpr uint8_t length() const
+    {
+        return _sig_bits;
+    }
 
     std::string to_hex() const
     {
         return _name.to_hex() + "/" + std::to_string(_sig_bits);
     }
 
-    friend constexpr bool operator==(const Namespace& a, const Namespace& b)
+    friend constexpr bool operator==(const Namespace &a, const Namespace &b)
     {
         return a._name == b._name && a._sig_bits == b._sig_bits;
     }
 
-    friend constexpr bool operator!=(const Namespace& a, const Namespace& b)
+    friend constexpr bool operator!=(const Namespace &a, const Namespace &b)
     {
         return !(a == b);
     }
 
-    friend constexpr bool operator>(const Namespace& a, const Namespace& b)
+    friend constexpr bool operator>(const Namespace &a, const Namespace &b)
     {
         return a._name > b._name;
     }
 
-    friend constexpr bool operator>(const Namespace& a, const Name& b)
+    friend constexpr bool operator>(const Namespace &a, const Name &b)
     {
-        return a._name > quicr::Namespace{ b, a._sig_bits };
+        return a._name > quicr::Namespace{b, a._sig_bits};
     }
 
-    friend constexpr bool operator>(const Name& a, const Namespace& b)
+    friend constexpr bool operator>(const Name &a, const Namespace &b)
     {
-        return quicr::Namespace{ a, b._sig_bits } > b._name;
+        return quicr::Namespace{a, b._sig_bits} > b._name;
     }
 
-    friend constexpr bool operator<(const Namespace& a, const Namespace& b)
+    friend constexpr bool operator<(const Namespace &a, const Namespace &b)
     {
         return a._name < b._name;
     }
 
-    friend constexpr bool operator<(const Namespace& a, const Name& b)
+    friend constexpr bool operator<(const Namespace &a, const Name &b)
     {
-        return a._name < quicr::Namespace{ b, a._sig_bits };
+        return a._name < quicr::Namespace{b, a._sig_bits};
     }
 
-    friend constexpr bool operator<(const Name& a, const Namespace& b)
+    friend constexpr bool operator<(const Name &a, const Namespace &b)
     {
-        return quicr::Namespace{ a, b._sig_bits } < b._name;
+        return quicr::Namespace{a, b._sig_bits} < b._name;
     }
 
-    friend std::ostream& operator<<(std::ostream& os, const Namespace& ns)
+    friend std::ostream &operator<<(std::ostream &os, const Namespace &ns)
     {
         return os << ns.to_hex();
     }
@@ -109,26 +114,28 @@ class Namespace
     uint8_t _sig_bits;
 };
 
-template<template<typename> class Comp>
+template <template <typename> class Comp>
 class NamespaceComparator : Comp<quicr::Namespace>
 {
-    using is_transparent = std::true_type;
     using base = Comp<quicr::Namespace>;
 
   public:
-    constexpr bool operator()(const Namespace& ns, const Name& name) const
+    using is_transparent = std::true_type;
+
+    using base::operator();
+
+    constexpr bool operator()(const Namespace &ns, const Name &name) const
     {
-        return base::operator()(ns, name);
+        return base::operator()(ns, {name, ns.length()});
     }
 
-    constexpr bool operator()(const Name& name, const Namespace& ns) const
+    constexpr bool operator()(const Name &name, const Namespace &ns) const
     {
-        return base::operator()(name, ns);
+        return base::operator()({name, ns.length()}, ns);
     }
 };
 
-template<class T,
-         class Allocator = std::allocator<std::pair<const quicr::Namespace, T>>>
-using namespace_map =
-  std::map<quicr::Namespace, T, NamespaceComparator<std::less>, Allocator>;
+template <class T, template <typename> class Comparator = std::less,
+          class Allocator = std::allocator<std::pair<const quicr::Namespace, T>>>
+using namespace_map = std::map<quicr::Namespace, T, NamespaceComparator<Comparator>, Allocator>;
 } // namespace quicr
diff --git a/test/namespace.cpp b/test/namespace.cpp
index f4b55da..9214653 100644
--- a/test/namespace.cpp
+++ b/test/namespace.cpp
@@ -48,3 +48,24 @@ TEST_CASE("quicr::Namespace String Constructor Test")
     CHECK_EQ(ns.name(), 0xA11CEE00000001010007000000000000_name);
     CHECK_EQ(ns.length(), 80);
 }
+
+
+TEST_CASE("quicr::Namespace Map Sorting Test")
+{
+    {
+        quicr::Name name = 0xABCDFFFFFFFFFFFFFFFFFFFFFFFFFFFF_name;
+        quicr::Namespace ns(name, 16);
+        quicr::namespace_map<int> ns_map{{ns, 101}};
+
+        CHECK_EQ(ns_map.count(ns), 1);
+        CHECK_EQ(ns_map.count(name), 1);
+    }
+    {
+        quicr::Name name = 0xABCDFFFFFFFFFFFFFFFFFFFFFFFFFFFF_name;
+        quicr::Namespace ns(name, 16);
+        quicr::namespace_map<int, std::greater> ns_map{{ns, 101}};
+
+        CHECK_EQ(ns_map.count(ns), 1);
+        CHECK_EQ(ns_map.count(name), 1);
+    }
+}