diff --git a/source/mijin/types/script_value.hpp b/source/mijin/types/script_value.hpp
index e9af045..03674f3 100644
--- a/source/mijin/types/script_value.hpp
+++ b/source/mijin/types/script_value.hpp
@@ -32,12 +32,16 @@ template<typename TScriptValue>
 struct ArrayValue
 {
     std::vector<TScriptValue> values;
+    
+    auto operator<=>(const ArrayValue&) const MIJIN_NOEXCEPT = default;
 };
 
 template<typename TScriptValue>
 struct MapValue
 {
     std::unordered_map<std::string, TScriptValue> values;
+
+    auto operator<=>(const MapValue&) const MIJIN_NOEXCEPT = default;
 };
 
 struct UndefinedValue
@@ -261,56 +265,66 @@ public:
             static_assert(mijin::always_false_v<T>, "Cannot convert to this type.");
         }
     }
+    
+    template<typename T>
+    Optional<const T&> toRef() const MIJIN_NOEXCEPT
+    {
+        if (std::holds_alternative<T>(base_))
+        {
+            return std::get<T>(base_);
+        }
+        return NULL_OPTIONAL;
+    }
 
     [[nodiscard]]
-    ScriptValue& operator[](std::size_t index) MIJIN_NOEXCEPT
+    concrete_t& operator[](std::size_t index) MIJIN_NOEXCEPT
     {
         MIJIN_ASSERT_FATAL(isArray(), "Called operator[size_t] on a non-array value.");
-        return std::get<array_t>(base_)[index];
+        return std::get<array_t>(base_).values[index];
     }
 
     [[nodiscard]]
-    const ScriptValue& operator[](std::size_t index) const MIJIN_NOEXCEPT
+    const concrete_t& operator[](std::size_t index) const MIJIN_NOEXCEPT
     {
         MIJIN_ASSERT_FATAL(isArray(), "Called operator[size_t] on a non-array value.");
-        return std::get<array_t>(base_)[index];
+        return std::get<array_t>(base_).values[index];
     }
 
     [[nodiscard]]
-    ScriptValue& operator[](const std::string& key) MIJIN_NOEXCEPT
+    concrete_t& operator[](const std::string& key)
     {
         MIJIN_ASSERT_FATAL(isMap(), "Called operator[string] on a non-map value.");
-        return std::get<map_t>(base_)[key];
+        return std::get<map_t>(base_).values.at(key);
     }
 
     [[nodiscard]]
-    const ScriptValue& operator[](const std::string& key) const MIJIN_NOEXCEPT
+    const concrete_t& operator[](const std::string& key) const
     {
         MIJIN_ASSERT_FATAL(isMap(), "Called operator[string] on a non-map value.");
-        return std::get<map_t>(base_)[key];
+        return std::get<map_t>(base_).values.at(key);
     }
 
     [[nodiscard]]
-    std::span<ScriptValue> arrayView() MIJIN_NOEXCEPT
+    std::span<concrete_t> arrayView() MIJIN_NOEXCEPT
     {
         MIJIN_ASSERT_FATAL(isArray(), "Called iterateArray() on a non-array value.");
         return std::get<array_t>(base_);
     }
 
     [[nodiscard]]
-    std::span<const ScriptValue> arrayView() const MIJIN_NOEXCEPT
+    std::span<const concrete_t> arrayView() const MIJIN_NOEXCEPT
     {
         MIJIN_ASSERT_FATAL(isArray(), "Called iterateArray() on a non-array value.");
         return std::get<array_t>(base_);
     }
 
-    MapView<std::string, ScriptValue> mapView() MIJIN_NOEXCEPT
+    MapView<std::string, concrete_t> mapView() MIJIN_NOEXCEPT
     {
         MIJIN_ASSERT_FATAL(isMap(), "Called iterateMap() on a non-map value.");
         return std::get<map_t>(base_);
     }
 
-    MapView<std::string, const ScriptValue> mapView() const MIJIN_NOEXCEPT
+    MapView<std::string, const concrete_t> mapView() const MIJIN_NOEXCEPT
     {
         MIJIN_ASSERT_FATAL(isMap(), "Called iterateMap() on a non-map value.");
         return std::get<map_t>(base_);