diff --git a/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/CollectionMappingProviders.kt b/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/CollectionMappingProviders.kt
new file mode 100644
index 0000000..15c4993
--- /dev/null
+++ b/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/CollectionMappingProviders.kt
@@ -0,0 +1,198 @@
+package xyz.xenondevs.commons.provider
+
+import java.lang.ref.WeakReference
+
+/**
+ * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
+ * using the [transform] function.
+ *
+ * [transform] should be a pure function.
+ */
+inline fun <T, R> Provider<Collection<T>>.mapEach(crossinline transform: (T) -> R): Provider<List<R>> =
+    mapEachTo({ size -> ArrayList(size) }, transform)
+
+/**
+ * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
+ * using the [transform] function.
+ *
+ * [transform] should be a pure function.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+inline fun <T, R> Provider<Collection<T>>.weakMapEach(crossinline transform: (T) -> R): Provider<List<R>> =
+    weakMapEachTo({ size -> ArrayList(size) }, transform)
+
+/**
+ * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
+ * using the [transform] function and adds the results to a collection created by [makeCollection].
+ *
+ * [makeCollection] and [transform] should be pure functions.
+ */
+inline fun <T, R, C : MutableCollection<in R>> Provider<Collection<T>>.mapEachTo(
+    crossinline makeCollection: (size: Int) -> C,
+    crossinline transform: (T) -> R
+): Provider<C> = map { it.mapTo(makeCollection(it.size), transform) }
+
+/**
+ * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
+ * using the [transform] function and adds the results to a collection created by [makeCollection].
+ *
+ * [makeCollection] and [transform] should be pure functions.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+inline fun <T, R, C : MutableCollection<in R>> Provider<Collection<T>>.weakMapEachTo(
+    crossinline makeCollection: (size: Int) -> C,
+    crossinline transform: (T) -> R
+): Provider<C> = weakMap { it.mapTo(makeCollection(it.size), transform) }
+
+/**
+ * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
+ * using the [transform] function and filters out all null results.
+ *
+ * [transform] should be a pure function.
+ */
+inline fun <T, R : Any> Provider<Collection<T>>.mapEachNotNull(crossinline transform: (T) -> R?): Provider<List<R>> =
+    mapEachNotNullTo(::ArrayList, transform)
+
+/**
+ * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
+ * using the [transform] function and filters out all null results.
+ *
+ * [transform] should be a pure function.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+inline fun <T, R : Any> Provider<Collection<T>>.weakMapEachNotNull(crossinline transform: (T) -> R?): Provider<List<R>> =
+    weakMapEachNotNullTo(::ArrayList, transform)
+
+/**
+ * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
+ * using the [transform] function and filters out all null results.
+ * The results are added to a collection created by [makeCollection].
+ *
+ * [makeCollection] and [transform] should be pure functions.
+ */
+inline fun <T, R : Any, C : MutableCollection<in R>> Provider<Collection<T>>.mapEachNotNullTo(
+    crossinline makeCollection: (size: Int) -> C,
+    crossinline transform: (T) -> R?
+): Provider<C> = map { it.mapNotNullTo(makeCollection(it.size), transform) }
+
+/**
+ * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
+ * using the [transform] function and filters out all null results.
+ * The results are added to a collection created by [makeCollection].
+ *
+ * [makeCollection] and [transform] should be pure functions.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+inline fun <T, R : Any, C : MutableCollection<in R>> Provider<Collection<T>>.weakMapEachNotNullTo(
+    crossinline makeCollection: (size: Int) -> C,
+    crossinline transform: (T) -> R?
+): Provider<C> = weakMap { it.mapNotNullTo(makeCollection(it.size), transform) }
+
+
+/**
+ * Creates and returns a new [Provider] that flat-maps the elements of the [Collection] obtained from [this][Provider]
+ * into a list using the [transform] function.
+ *
+ * [transform] should be a pure function.
+ */
+@JvmName("flatMapCollection")
+inline fun <T, R> Provider<Collection<T>>.flatMapCollection(crossinline transform: (T) -> Iterable<R>): Provider<List<R>> =
+    flatMapCollectionTo({ size -> ArrayList(size) }, transform)
+
+/**
+ * Creates and returns a new [Provider] that flat-maps the elements of the [Collection] obtained from [this][Provider]
+ * into a list using the [transform] function.
+ *
+ * [transform] should be a pure function.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+@JvmName("weakFlatMapCollection")
+inline fun <T, R> Provider<Collection<T>>.weakFlatMapCollection(crossinline transform: (T) -> Iterable<R>): Provider<List<R>> =
+    weakFlatMapCollectionTo({ size -> ArrayList(size) }, transform)
+
+/**
+ * Creates and returns a new [Provider] that flat-maps the elements of the [Collection] obtained from [this][Provider]
+ * into a collection created by [makeCollection] using the [transform] function.
+ *
+ * [makeCollection] and [transform] should be pure functions.
+ */
+inline fun <T, R, C : MutableCollection<in R>> Provider<Collection<T>>.flatMapCollectionTo(
+    crossinline makeCollection: (size: Int) -> C,
+    crossinline transform: (T) -> Iterable<R>
+): Provider<C> = map { it.flatMapTo(makeCollection(it.size), transform) }
+
+/**
+ * Creates and returns a new [Provider] that flat-maps the elements of the [Collection] obtained from [this][Provider]
+ * into a collection created by [makeCollection] using the [transform] function.
+ *
+ * [makeCollection] and [transform] should be pure functions.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+inline fun <T, R, C : MutableCollection<in R>> Provider<Collection<T>>.weakFlatMapCollectionTo(
+    crossinline makeCollection: (size: Int) -> C,
+    crossinline transform: (T) -> Iterable<R>
+): Provider<C> = weakMap { it.flatMapTo(makeCollection(it.size), transform) }
+
+/**
+ * Creates and returns a new [Provider] that flattens the [List] of [Lists][List] obtained from [this][Provider].
+ */
+fun <T> Provider<Iterable<Iterable<T>>>.flattenIterables(): Provider<List<T>> =
+    map { it.flatten() }
+
+/**
+ * Creates and returns a new [Provider] that flattens the [List] of [Lists][List] obtained from [this][Provider].
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+fun <T> Provider<Iterable<Iterable<T>>>.weakFlattenIterables(): Provider<List<T>> =
+    weakMap { it.flatten() }
+
+/**
+ * Creates and returns a new [Provider] that merges all [Maps][Map] obtained from [this][Provider] into a single [Map].
+ */
+fun <K, V> Provider<List<Map<K, V>>>.mergeMaps(): Provider<Map<K, V>> =
+    mergeMapsTo(::HashMap)
+
+/**
+ * Creates and returns a new [Provider] that merges all [Maps][Map] obtained from [this][Provider] into a single [Map].
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+fun <K, V> Provider<List<Map<K, V>>>.weakMergeMaps(): Provider<Map<K, V>> =
+    weakMergeMapsTo(::HashMap)
+
+/**
+ * Creates and returns a new [Provider] that merges all [Maps][Map] obtained from [this][Provider] into a single [Map],
+ * which is created by the [makeMap] function.
+ *
+ * [makeMap] should be a pure function.
+ */
+fun <K, V, M : MutableMap<in K, in V>> Provider<List<Map<K, V>>>.mergeMapsTo(makeMap: (size: Int) -> M): Provider<M> =
+    map { maps ->
+        val size = maps.sumOf { it.size }
+        val map = makeMap(size)
+        maps.forEach(map::putAll)
+        map
+    }
+
+/**
+ * Creates and returns a new [Provider] that merges all [Maps][Map] obtained from [this][Provider] into a single [Map],
+ * which is created by the [makeMap] function.
+ *
+ * [makeMap] should be a pure function.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+fun <K, V, M : MutableMap<in K, in V>> Provider<List<Map<K, V>>>.weakMergeMapsTo(makeMap: (size: Int) -> M): Provider<M> =
+    weakMap { maps ->
+        val size = maps.sumOf { it.size }
+        val map = makeMap(size)
+        maps.forEach(map::putAll)
+        map
+    }
diff --git a/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/MappingProviders.kt b/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/MappingProviders.kt
index af9da05..479b9b6 100644
--- a/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/MappingProviders.kt
+++ b/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/MappingProviders.kt
@@ -97,261 +97,6 @@ inline fun <T : Any, R> Provider<T?>.mapNonNull(crossinline transform: (T) -> R)
 inline fun <T : Any, R> Provider<T?>.weakMapNonNull(crossinline transform: (T) -> R): Provider<R?> =
     weakMap { it?.let(transform) }
 
-/**
- * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
- * using the [transform] function.
- *
- * [transform] should be a pure function.
- */
-inline fun <T, R> Provider<Collection<T>>.mapEach(crossinline transform: (T) -> R): Provider<List<R>> =
-    mapEachTo({ size -> ArrayList(size) }, transform)
-
-/**
- * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
- * using the [transform] function.
- *
- * [transform] should be a pure function.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-inline fun <T, R> Provider<Collection<T>>.weakMapEach(crossinline transform: (T) -> R): Provider<List<R>> =
-    weakMapEachTo({ size -> ArrayList(size) }, transform)
-
-/**
- * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
- * using the [transform] function and adds the results to a collection created by [makeCollection].
- * 
- * [makeCollection] and [transform] should be pure functions.
- */
-inline fun <T, R, C : MutableCollection<in R>> Provider<Collection<T>>.mapEachTo(
-    crossinline makeCollection: (size: Int) -> C,
-    crossinline transform: (T) -> R
-): Provider<C> = map { it.mapTo(makeCollection(it.size), transform) }
-
-/**
- * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
- * using the [transform] function and adds the results to a collection created by [makeCollection].
- *
- * [makeCollection] and [transform] should be pure functions.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-inline fun <T, R, C : MutableCollection<in R>> Provider<Collection<T>>.weakMapEachTo(
-    crossinline makeCollection: (size: Int) -> C,
-    crossinline transform: (T) -> R
-): Provider<C> = weakMap { it.mapTo(makeCollection(it.size), transform) }
-
-/**
- * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
- * using the [transform] function and filters out all null results.
- *
- * [transform] should be a pure function.
- */
-inline fun <T, R : Any> Provider<Collection<T>>.mapEachNotNull(crossinline transform: (T) -> R?): Provider<List<R>> =
-    mapEachNotNullTo(::ArrayList, transform)
-
-/**
- * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
- * using the [transform] function and filters out all null results.
- *
- * [transform] should be a pure function.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-inline fun <T, R : Any> Provider<Collection<T>>.weakMapEachNotNull(crossinline transform: (T) -> R?): Provider<List<R>> =
-    weakMapEachNotNullTo(::ArrayList, transform)
-
-/**
- * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
- * using the [transform] function and filters out all null results.
- * The results are added to a collection created by [makeCollection].
- *
- * [makeCollection] and [transform] should be pure functions.
- */
-inline fun <T, R : Any, C : MutableCollection<in R>> Provider<Collection<T>>.mapEachNotNullTo(
-    crossinline makeCollection: (size: Int) -> C,
-    crossinline transform: (T) -> R?
-): Provider<C> = map { it.mapNotNullTo(makeCollection(it.size), transform) }
-
-/**
- * Creates and returns a new [Provider] that maps each element of the [Collection] obtained from [this][Provider]
- * using the [transform] function and filters out all null results.
- * The results are added to a collection created by [makeCollection].
- *
- * [makeCollection] and [transform] should be pure functions.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-inline fun <T, R : Any, C : MutableCollection<in R>> Provider<Collection<T>>.weakMapEachNotNullTo(
-    crossinline makeCollection: (size: Int) -> C,
-    crossinline transform: (T) -> R?
-): Provider<C> = weakMap { it.mapNotNullTo(makeCollection(it.size), transform) }
-
-
-/**
- * Creates and returns a new [Provider] that flat-maps the elements of the [Collection] obtained from [this][Provider]
- * into a list using the [transform] function.
- *
- * [transform] should be a pure function.
- */
-@JvmName("flatMapCollection")
-inline fun <T, R> Provider<Collection<T>>.flatMapCollection(crossinline transform: (T) -> Iterable<R>): Provider<List<R>> =
-    flatMapCollectionTo({ size -> ArrayList(size) }, transform)
-
-/**
- * Creates and returns a new [Provider] that flat-maps the elements of the [Collection] obtained from [this][Provider]
- * into a list using the [transform] function.
- *
- * [transform] should be a pure function.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-@JvmName("weakFlatMapCollection")
-inline fun <T, R> Provider<Collection<T>>.weakFlatMapCollection(crossinline transform: (T) -> Iterable<R>): Provider<List<R>> =
-    weakFlatMapCollectionTo({ size -> ArrayList(size) }, transform)
-
-/**
- * Creates and returns a new [Provider] that flat-maps the elements of the [Collection] obtained from [this][Provider]
- * into a collection created by [makeCollection] using the [transform] function.
- *
- * [makeCollection] and [transform] should be pure functions.
- */
-inline fun <T, R, C : MutableCollection<in R>> Provider<Collection<T>>.flatMapCollectionTo(
-    crossinline makeCollection: (size: Int) -> C,
-    crossinline transform: (T) -> Iterable<R>
-): Provider<C> = map { it.flatMapTo(makeCollection(it.size), transform) }
-
-/**
- * Creates and returns a new [Provider] that flat-maps the elements of the [Collection] obtained from [this][Provider]
- * into a collection created by [makeCollection] using the [transform] function.
- *
- * [makeCollection] and [transform] should be pure functions.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-inline fun <T, R, C : MutableCollection<in R>> Provider<Collection<T>>.weakFlatMapCollectionTo(
-    crossinline makeCollection: (size: Int) -> C,
-    crossinline transform: (T) -> Iterable<R>
-): Provider<C> = weakMap { it.flatMapTo(makeCollection(it.size), transform) }
-
-/**
- * Creates and returns a new [Provider] that flattens the [List] of [Lists][List] obtained from [this][Provider].
- */
-fun <T> Provider<Iterable<Iterable<T>>>.flattenIterables(): Provider<List<T>> =
-    map { it.flatten() }
-
-/**
- * Creates and returns a new [Provider] that flattens the [List] of [Lists][List] obtained from [this][Provider].
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-fun <T> Provider<Iterable<Iterable<T>>>.weakFlattenIterables(): Provider<List<T>> =
-    weakMap { it.flatten() }
-
-/**
- * Creates and returns a new [Provider] that merges all [Maps][Map] obtained from [this][Provider] into a single [Map].
- */
-fun <K, V> Provider<List<Map<K, V>>>.mergeMaps(): Provider<Map<K, V>> =
-    mergeMapsTo(::HashMap)
-
-/**
- * Creates and returns a new [Provider] that merges all [Maps][Map] obtained from [this][Provider] into a single [Map].
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-fun <K, V> Provider<List<Map<K, V>>>.weakMergeMaps(): Provider<Map<K, V>> =
-    weakMergeMapsTo(::HashMap)
-
-/**
- * Creates and returns a new [Provider] that merges all [Maps][Map] obtained from [this][Provider] into a single [Map],
- * which is created by the [makeMap] function.
- * 
- * [makeMap] should be a pure function.
- */
-fun <K, V, M : MutableMap<in K, in V>> Provider<List<Map<K, V>>>.mergeMapsTo(makeMap: (size: Int) -> M): Provider<M> =
-    map { maps ->
-        val size = maps.sumOf { it.size }
-        val map = makeMap(size)
-        maps.forEach(map::putAll)
-        map
-    }
-
-/**
- * Creates and returns a new [Provider] that merges all [Maps][Map] obtained from [this][Provider] into a single [Map],
- * which is created by the [makeMap] function.
- *
- * [makeMap] should be a pure function.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-fun <K, V, M : MutableMap<in K, in V>> Provider<List<Map<K, V>>>.weakMergeMapsTo(makeMap: (size: Int) -> M): Provider<M> =
-    weakMap { maps ->
-        val size = maps.sumOf { it.size }
-        val map = makeMap(size)
-        maps.forEach(map::putAll)
-        map
-    }
-
-/**
- * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
- * with a message generated by [message] if [condition] fails.
- * 
- * [condition] and [message] should be pure functions.
- */
-inline fun <T> Provider<T>.require(
-    crossinline condition: (T) -> Boolean,
-    crossinline message: (T) -> String
-): Provider<T> = map { require(condition(it)) { message(it) }; it }
-
-/**
- * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
- * with a message generated by [message] if [condition] fails.
- *
- * [condition] and [message] should be pure functions.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-inline fun <T> Provider<T>.weakRequire(
-    crossinline condition: (T) -> Boolean,
-    crossinline message: (T) -> String
-): Provider<T> = weakMap { require(condition(it)) { message(it) }; it }
-
-/**
- * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
- * with [message] if the value is `null`.
- */
-fun <T : Any> Provider<T?>.requireNotNull(message: String = "Required value was null."): Provider<T> =
-    requireNotNull { message }
-
-/**
- * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
- * with [message] if the value is `null`.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-fun <T : Any> Provider<T?>.weakRequireNotNull(message: String = "Required value was null."): Provider<T> =
-    weakRequireNotNull { message }
-
-/**
- * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
- * with a message generated by [message] if the value is `null`.
- * 
- * [message] should be a pure function.
- */
-inline fun <T : Any> Provider<T?>.requireNotNull(crossinline message: () -> String): Provider<T> =
-    map { requireNotNull(it, message); it }
-
-/**
- * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
- * with a message generated by [message] if the value is `null`.
- *
- * [message] should be a pure function.
- * 
- * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
- */
-inline fun <T : Any> Provider<T?>.weakRequireNotNull(crossinline message: () -> String): Provider<T> =
-    weakMap { requireNotNull(it, message); it }
-
 private class MappingProvider<P, T>(
     private val parent: AbstractProvider<P>,
     private val transform: (P) -> T,
diff --git a/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/RequirementProviders.kt b/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/RequirementProviders.kt
new file mode 100644
index 0000000..424133e
--- /dev/null
+++ b/commons-provider/src/main/kotlin/xyz/xenondevs/commons/provider/RequirementProviders.kt
@@ -0,0 +1,63 @@
+package xyz.xenondevs.commons.provider
+
+import java.lang.ref.WeakReference
+
+/**
+ * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
+ * with a message generated by [message] if [condition] fails.
+ *
+ * [condition] and [message] should be pure functions.
+ */
+inline fun <T> Provider<T>.require(
+    crossinline condition: (T) -> Boolean,
+    crossinline message: (T) -> String
+): Provider<T> = map { require(condition(it)) { message(it) }; it }
+
+/**
+ * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
+ * with a message generated by [message] if [condition] fails.
+ *
+ * [condition] and [message] should be pure functions.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+inline fun <T> Provider<T>.weakRequire(
+    crossinline condition: (T) -> Boolean,
+    crossinline message: (T) -> String
+): Provider<T> = weakMap { require(condition(it)) { message(it) }; it }
+
+/**
+ * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
+ * with [message] if the value is `null`.
+ */
+fun <T : Any> Provider<T?>.requireNotNull(message: String = "Required value was null."): Provider<T> =
+    requireNotNull { message }
+
+/**
+ * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
+ * with [message] if the value is `null`.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+fun <T : Any> Provider<T?>.weakRequireNotNull(message: String = "Required value was null."): Provider<T> =
+    weakRequireNotNull { message }
+
+/**
+ * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
+ * with a message generated by [message] if the value is `null`.
+ *
+ * [message] should be a pure function.
+ */
+inline fun <T : Any> Provider<T?>.requireNotNull(crossinline message: () -> String): Provider<T> =
+    map { requireNotNull(it, message); it }
+
+/**
+ * Creates and returns a new [Provider] that throws an [IllegalArgumentException]
+ * with a message generated by [message] if the value is `null`.
+ *
+ * [message] should be a pure function.
+ *
+ * The returned provider will only be stored in a [WeakReference] in the parent provider ([this][MutableProvider]).
+ */
+inline fun <T : Any> Provider<T?>.weakRequireNotNull(crossinline message: () -> String): Provider<T> =
+    weakMap { requireNotNull(it, message); it }
\ No newline at end of file