@monstermann/map 0.1.2 → 0.2.0

package/dist/Map/mapOr.d.mts

@@ -1,19 +1,29 @@
-import { MapMap } from "./internals/types.mjs";
-
 //#region src/Map/mapOr.d.ts
-
 /**
+ * # mapOr
+ *
  * ```ts
- * function Map.mapOr(map, key, transform, or)
+ * function Map.mapOr<K, V, U>(
+ *     target: ReadonlyMap<K, V>,
+ *     key: NoInfer<K>,
+ *     transform: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => V,
+ *     or: U,
+ * ): ReadonlyMap<K, V> | U
  * ```
  *
+ * Transforms the value at the specified key using the provided function, or returns the fallback value if the key doesn't exist.
+ *
  * ## Example
  *
- * ```ts
+ * ```ts [data-first]
  * import { Map } from "@monstermann/map";
  *
  * Map.mapOr(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -23,7 +33,7 @@ import { MapMap } from "./internals/types.mjs";
  * ); // Map(2) { "a" => 2, "b" => 2 }
  *
  * Map.mapOr(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -33,11 +43,11 @@ import { MapMap } from "./internals/types.mjs";
  * ); // null
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Map } from "@monstermann/map";
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -45,19 +55,20 @@ import { MapMap } from "./internals/types.mjs";
  * ); // Map(2) { "a" => 2, "b" => 2 }
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
  *     Map.mapOr("c", (value) => value * 2, null),
  * ); // null
  * ```
+ *
  */
 declare const mapOr: {
-  <K, V, U>(key: NoInfer<K>, transform: MapMap<K, V>, or: U): (target: Map<K, V>) => Map<K, V> | U;
-  <K, V, U>(key: NoInfer<K>, transform: MapMap<K, V>, or: U): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V> | U;
-  <K, V, U>(target: Map<K, V>, key: NoInfer<K>, transform: MapMap<K, V>, or: U): Map<K, V> | U;
-  <K, V, U>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: MapMap<K, V>, or: U): ReadonlyMap<K, V> | U;
+  <K, V, U>(key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V, or: U): (target: Map<K, V>) => Map<K, V> | U;
+  <K, V, U>(key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V, or: U): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V> | U;
+  <K, V, U>(target: Map<K, V>, key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V, or: U): Map<K, V> | U;
+  <K, V, U>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V, or: U): ReadonlyMap<K, V> | U;
 };
 //#endregion
 export { mapOr };

package/dist/Map/mapOr.mjs

@@ -3,17 +3,30 @@ import { cloneMap } from "@monstermann/remmi";
 
 //#region src/Map/mapOr.ts
 /**
+* # mapOr
+*
 * ```ts
-* function Map.mapOr(map, key, transform, or)
+* function Map.mapOr<K, V, U>(
+*     target: ReadonlyMap<K, V>,
+*     key: NoInfer<K>,
+*     transform: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => V,
+*     or: U,
+* ): ReadonlyMap<K, V> | U
 * ```
 *
+* Transforms the value at the specified key using the provided function, or returns the fallback value if the key doesn't exist.
+*
 * ## Example
 *
-* ```ts
+* ```ts [data-first]
 * import { Map } from "@monstermann/map";
 *
 * Map.mapOr(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -23,7 +36,7 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 2 }
 *
 * Map.mapOr(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -33,11 +46,11 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // null
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Map } from "@monstermann/map";
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -45,13 +58,14 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 2 }
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
 *     Map.mapOr("c", (value) => value * 2, null),
 * ); // null
 * ```
+*
 */
 const mapOr = dfdlT((target, key, transform, or) => {
 	if (!target.has(key)) return or;

package/dist/Map/mapOrElse.d.mts

@@ -1,19 +1,29 @@
-import { MapMap, OrElse } from "./internals/types.mjs";
-
 //#region src/Map/mapOrElse.d.ts
-
 /**
+ * # mapOrElse
+ *
  * ```ts
- * function Map.mapOrElse(map, key, transform, orElse)
+ * function Map.mapOrElse<K, V, U>(
+ *     target: ReadonlyMap<K, V>,
+ *     key: NoInfer<K>,
+ *     transform: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => V,
+ *     orElse: (target: ReadonlyMap<K, V>) => U,
+ * ): ReadonlyMap<K, V> | U
  * ```
  *
+ * Transforms the value at the specified key using the provided function, or calls the fallback function if the key doesn't exist.
+ *
  * ## Example
  *
- * ```ts
+ * ```ts [data-first]
  * import { Map } from "@monstermann/map";
  *
  * Map.mapOrElse(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -23,7 +33,7 @@ import { MapMap, OrElse } from "./internals/types.mjs";
  * ); // Map(2) { "a" => 2, "b" => 2 }
  *
  * Map.mapOrElse(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -33,11 +43,11 @@ import { MapMap, OrElse } from "./internals/types.mjs";
  * ); // 2
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Map } from "@monstermann/map";
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -49,7 +59,7 @@ import { MapMap, OrElse } from "./internals/types.mjs";
  * ); // Map(2) { "a" => 2, "b" => 2 }
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -60,12 +70,13 @@ import { MapMap, OrElse } from "./internals/types.mjs";
  *     ),
  * ); // 2
  * ```
+ *
  */
 declare const mapOrElse: {
-  <K, V, U>(key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): (target: Map<K, V>) => Map<K, V> | U;
-  <K, V, U>(key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V> | U;
-  <K, V, U>(target: Map<K, V>, key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): Map<K, V> | U;
-  <K, V, U>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: MapMap<K, V>, orElse: OrElse<K, V, U>): ReadonlyMap<K, V> | U;
+  <K, V, U>(key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V, orElse: (target: ReadonlyMap<K, V>) => U): (target: Map<K, V>) => Map<K, V> | U;
+  <K, V, U>(key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V, orElse: (target: ReadonlyMap<K, V>) => U): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V> | U;
+  <K, V, U>(target: Map<K, V>, key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V, orElse: (target: ReadonlyMap<K, V>) => U): Map<K, V> | U;
+  <K, V, U>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V, orElse: (target: ReadonlyMap<K, V>) => U): ReadonlyMap<K, V> | U;
 };
 //#endregion
 export { mapOrElse };

package/dist/Map/mapOrElse.mjs

@@ -3,17 +3,30 @@ import { cloneMap } from "@monstermann/remmi";
 
 //#region src/Map/mapOrElse.ts
 /**
+* # mapOrElse
+*
 * ```ts
-* function Map.mapOrElse(map, key, transform, orElse)
+* function Map.mapOrElse<K, V, U>(
+*     target: ReadonlyMap<K, V>,
+*     key: NoInfer<K>,
+*     transform: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => V,
+*     orElse: (target: ReadonlyMap<K, V>) => U,
+* ): ReadonlyMap<K, V> | U
 * ```
 *
+* Transforms the value at the specified key using the provided function, or calls the fallback function if the key doesn't exist.
+*
 * ## Example
 *
-* ```ts
+* ```ts [data-first]
 * import { Map } from "@monstermann/map";
 *
 * Map.mapOrElse(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -23,7 +36,7 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 2 }
 *
 * Map.mapOrElse(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -33,11 +46,11 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // 2
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Map } from "@monstermann/map";
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -49,7 +62,7 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 2 }
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -60,6 +73,7 @@ import { cloneMap } from "@monstermann/remmi";
 *     ),
 * ); // 2
 * ```
+*
 */
 const mapOrElse = dfdlT((target, key, transform, orElse) => {
 	if (!target.has(key)) return orElse(target);

package/dist/Map/mapOrThrow.d.mts

@@ -1,19 +1,28 @@
-import { MapMap } from "./internals/types.mjs";
-
 //#region src/Map/mapOrThrow.d.ts
-
 /**
+ * # mapOrThrow
+ *
  * ```ts
- * function Map.mapOrThrow(map, key, transform)
+ * function Map.mapOrThrow<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     key: NoInfer<K>,
+ *     transform: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => V,
+ * ): ReadonlyMap<K, V>
  * ```
  *
+ * Transforms the value at the specified key using the provided function, or throws an error if the key doesn't exist.
+ *
  * ## Example
  *
- * ```ts
+ * ```ts [data-first]
  * import { Map } from "@monstermann/map";
  *
  * Map.mapOrThrow(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -22,7 +31,7 @@ import { MapMap } from "./internals/types.mjs";
  * ); // Map(2) { "a" => 2, "b" => 2 }
  *
  * Map.mapOrThrow(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -31,11 +40,11 @@ import { MapMap } from "./internals/types.mjs";
  * ); // throws FnError
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Map } from "@monstermann/map";
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
@@ -43,19 +52,20 @@ import { MapMap } from "./internals/types.mjs";
  * ); // Map(2) { "a" => 2, "b" => 2 }
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *     ]),
  *     Map.mapOrThrow("c", (value) => value * 2),
  * ); // throws FnError
  * ```
+ *
  */
 declare const mapOrThrow: {
-  <K, V>(key: NoInfer<K>, transform: MapMap<K, V>): (target: Map<K, V>) => Map<K, V>;
-  <K, V>(key: NoInfer<K>, transform: MapMap<K, V>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  <K, V>(target: Map<K, V>, key: NoInfer<K>, transform: MapMap<K, V>): Map<K, V>;
-  <K, V>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: MapMap<K, V>): ReadonlyMap<K, V>;
+  <K, V>(key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V): (target: Map<K, V>) => Map<K, V>;
+  <K, V>(key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  <K, V>(target: Map<K, V>, key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V): Map<K, V>;
+  <K, V>(target: ReadonlyMap<K, V>, key: NoInfer<K>, transform: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => V): ReadonlyMap<K, V>;
 };
 //#endregion
 export { mapOrThrow };

package/dist/Map/mapOrThrow.mjs

@@ -3,17 +3,29 @@ import { cloneMap } from "@monstermann/remmi";
 
 //#region src/Map/mapOrThrow.ts
 /**
+* # mapOrThrow
+*
 * ```ts
-* function Map.mapOrThrow(map, key, transform)
+* function Map.mapOrThrow<K, V>(
+*     target: ReadonlyMap<K, V>,
+*     key: NoInfer<K>,
+*     transform: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => V,
+* ): ReadonlyMap<K, V>
 * ```
 *
+* Transforms the value at the specified key using the provided function, or throws an error if the key doesn't exist.
+*
 * ## Example
 *
-* ```ts
+* ```ts [data-first]
 * import { Map } from "@monstermann/map";
 *
 * Map.mapOrThrow(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -22,7 +34,7 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 2 }
 *
 * Map.mapOrThrow(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -31,11 +43,11 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // throws FnError
 * ```
 *
-* ```ts
+* ```ts [data-last]
 * import { Map } from "@monstermann/map";
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
@@ -43,13 +55,14 @@ import { cloneMap } from "@monstermann/remmi";
 * ); // Map(2) { "a" => 2, "b" => 2 }
 *
 * pipe(
-*     Map.create([
+*     new Map([
 *         ["a", 1],
 *         ["b", 2],
 *     ]),
 *     Map.mapOrThrow("c", (value) => value * 2),
 * ); // throws FnError
 * ```
+*
 */
 const mapOrThrow = dfdlT((target, key, transform) => {
 	if (!target.has(key)) throw new Error("Map.mapOrThrow: Key does not exist.");

package/dist/Map/none.d.mts

@@ -0,0 +1,58 @@
+//#region src/Map/none.d.ts
+/**
+ * # none
+ *
+ * ```ts
+ * function Map.none<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     predicate: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ * ): boolean
+ * ```
+ *
+ * Returns `true` if no entries in the map satisfy the provided `predicate` function, otherwise returns `false`.
+ *
+ * ## Example
+ *
+ * ```ts [data-first]
+ * import { Map } from "@monstermann/map";
+ *
+ * Map.none(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     (value) => value > 10,
+ * ); // true
+ * ```
+ *
+ * ```ts [data-last]
+ * import { Map } from "@monstermann/map";
+ *
+ * pipe(
+ *     new Map([
+ *         ["a", 1],
+ *         ["b", 2],
+ *         ["c", 3],
+ *     ]),
+ *     Map.none((value) => value > 10),
+ * ); // true
+ * ```
+ *
+ */
+declare const none: {
+  <K, V, U extends V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): (target: Map<K, V>) => target is Map<K, Exclude<V, U>>;
+  <K, V, U extends V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): (target: ReadonlyMap<K, V>) => target is ReadonlyMap<K, Exclude<V, U>>;
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): (target: Map<K, V>) => boolean;
+  <K, V>(predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): (target: ReadonlyMap<K, V>) => boolean;
+  <K, V, U extends V>(target: Map<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): target is Map<K, Exclude<V, U>>;
+  <K, V, U extends V>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): target is ReadonlyMap<K, Exclude<V, U>>;
+  <K, V>(target: Map<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): boolean;
+  <K, V>(target: ReadonlyMap<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): boolean;
+};
+//#endregion
+export { none };

package/dist/Map/none.mjs

@@ -0,0 +1,55 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Map/none.ts
+/**
+* # none
+*
+* ```ts
+* function Map.none<K, V>(
+*     target: ReadonlyMap<K, V>,
+*     predicate: (
+*         value: NoInfer<V>,
+*         key: NoInfer<K>,
+*         target: ReadonlyMap<K, V>,
+*     ) => boolean,
+* ): boolean
+* ```
+*
+* Returns `true` if no entries in the map satisfy the provided `predicate` function, otherwise returns `false`.
+*
+* ## Example
+*
+* ```ts [data-first]
+* import { Map } from "@monstermann/map";
+*
+* Map.none(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     (value) => value > 10,
+* ); // true
+* ```
+*
+* ```ts [data-last]
+* import { Map } from "@monstermann/map";
+*
+* pipe(
+*     new Map([
+*         ["a", 1],
+*         ["b", 2],
+*         ["c", 3],
+*     ]),
+*     Map.none((value) => value > 10),
+* ); // true
+* ```
+*
+*/
+const none = dfdlT(((target, predicate) => {
+	for (const [key, value] of target) if (predicate(value, key, target)) return false;
+	return true;
+}), 2);
+
+//#endregion
+export { none };

package/dist/Map/reject.d.mts

@@ -1,19 +1,27 @@
-import { MapGuard, MapPredicate } from "./internals/types.mjs";
-
 //#region src/Map/reject.d.ts
-
 /**
+ * # reject
+ *
  * ```ts
- * function Map.reject(map, by)
+ * function Map.reject<K, V>(
+ *     target: ReadonlyMap<K, V>,
+ *     by: (
+ *         value: NoInfer<V>,
+ *         key: NoInfer<K>,
+ *         target: ReadonlyMap<K, V>,
+ *     ) => boolean,
+ * ): ReadonlyMap<K, V>
  * ```
  *
+ * Returns a new map excluding entries that satisfy the predicate function.
+ *
  * ## Example
  *
- * ```ts
+ * ```ts [data-first]
  * import { Map } from "@monstermann/map";
  *
  * Map.reject(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *         ["c", 3],
@@ -22,11 +30,11 @@ import { MapGuard, MapPredicate } from "./internals/types.mjs";
  * ); // Map(1) { "a" => 1 }
  * ```
  *
- * ```ts
+ * ```ts [data-last]
  * import { Map } from "@monstermann/map";
  *
  * pipe(
- *     Map.create([
+ *     new Map([
  *         ["a", 1],
  *         ["b", 2],
  *         ["c", 3],
@@ -34,16 +42,17 @@ import { MapGuard, MapPredicate } from "./internals/types.mjs";
  *     Map.reject((value) => value > 1),
  * ); // Map(1) { "a" => 1 }
  * ```
+ *
  */
 declare const reject: {
-  <K, V, U extends V>(by: MapGuard<K, V, U>): (target: Map<K, V>) => Map<K, Exclude<V, U>>;
-  <K, V, U extends V>(by: MapGuard<K, V, U>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, Exclude<V, U>>;
-  <K, V>(by: MapPredicate<K, V>): (target: Map<K, V>) => Map<K, V>;
-  <K, V>(by: MapPredicate<K, V>): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
-  <K, V, U extends V>(target: Map<K, V>, by: MapGuard<K, V, U>): Map<K, Exclude<V, U>>;
-  <K, V, U extends V>(target: ReadonlyMap<K, V>, by: MapGuard<K, V, U>): ReadonlyMap<K, Exclude<V, U>>;
-  <K, V>(target: Map<K, V>, by: MapPredicate<K, V>): Map<K, V>;
-  <K, V>(target: ReadonlyMap<K, V>, by: MapPredicate<K, V>): ReadonlyMap<K, V>;
+  <K, V, U extends V>(by: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): (target: Map<K, V>) => Map<K, Exclude<V, U>>;
+  <K, V, U extends V>(by: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, Exclude<V, U>>;
+  <K, V>(by: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): (target: Map<K, V>) => Map<K, V>;
+  <K, V>(by: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): (target: ReadonlyMap<K, V>) => ReadonlyMap<K, V>;
+  <K, V, U extends V>(target: Map<K, V>, by: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): Map<K, Exclude<V, U>>;
+  <K, V, U extends V>(target: ReadonlyMap<K, V>, by: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => value is U): ReadonlyMap<K, Exclude<V, U>>;
+  <K, V>(target: Map<K, V>, by: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): Map<K, V>;
+  <K, V>(target: ReadonlyMap<K, V>, by: (value: NoInfer<V>, key: NoInfer<K>, target: ReadonlyMap<K, V>) => boolean): ReadonlyMap<K, V>;
 };
 //#endregion
 export { reject };