Fix: Prevent stack overflow with Jest matchers and complex objects

sindresorhus · sindresorhus · commit 28d61f4d4297 · 2025-09-16T05:46:45.000+07:00
Fixes #45
diff --git a/index.d.ts b/index.d.ts
@@ -53,6 +53,8 @@ export interface Options {
 	Recurse nested objects and objects in arrays.
 
 	@default false
+
+	Built-in objects like `RegExp`, `Error`, `Date`, and `Blob` are not recursed into. Special objects like Jest matchers are also automatically excluded.
 	*/
 	readonly deep?: boolean;
 
diff --git a/index.js b/index.js
@@ -6,33 +6,34 @@ const isObjectCustom = value =>
 	&& !(value instanceof RegExp)
 	&& !(value instanceof Error)
 	&& !(value instanceof Date)
-	&& !(globalThis.Blob && value instanceof globalThis.Blob);
+	&& !(globalThis.Blob && value instanceof globalThis.Blob)
+	&& typeof value.$$typeof !== 'symbol' // Jest asymmetric matchers
+	&& typeof value.asymmetricMatch !== 'function'; // Jest matchers
 
 export const mapObjectSkip = Symbol('mapObjectSkip');
 
 const _mapObject = (object, mapper, options, isSeen = new WeakMap()) => {
-	options = {
+	const {
+		target = {},
+		...processOptions
+	} = {
 		deep: false,
-		target: {},
 		...options,
 	};
 
 	if (isSeen.has(object)) {
 		return isSeen.get(object);
 	}
 
-	isSeen.set(object, options.target);
+	isSeen.set(object, target);
 
-	const {target} = options;
-	delete options.target;
-
-	const mapArray = array => array.map(element => isObjectCustom(element) ? _mapObject(element, mapper, options, isSeen) : element);
+	const mapArray = array => array.map(element => isObjectCustom(element) ? _mapObject(element, mapper, processOptions, isSeen) : element);
 	if (Array.isArray(object)) {
 		return mapArray(object);
 	}
 
 	for (const [key, value] of Object.entries(object)) {
-		const mapResult = mapper(key, value, object);
+		const mapResult = mapper(key, value);
 
 		if (mapResult === mapObjectSkip) {
 			continue;
@@ -45,10 +46,10 @@ const _mapObject = (object, mapper, options, isSeen = new WeakMap()) => {
 			continue;
 		}
 
-		if (options.deep && shouldRecurse && isObjectCustom(newValue)) {
+		if (processOptions.deep && shouldRecurse && isObjectCustom(newValue)) {
 			newValue = Array.isArray(newValue)
 				? mapArray(newValue)
-				: _mapObject(newValue, mapper, options, isSeen);
+				: _mapObject(newValue, mapper, processOptions, isSeen);
 		}
 
 		target[newKey] = newValue;
@@ -67,7 +68,7 @@ export default function mapObject(object, mapper, options) {
 	}
 
 	// Ensure the third mapper argument is always the original input object
-	const root = object;
-	const mapperWithRoot = (key, value) => mapper(key, value, root);
+	const mapperWithRoot = (key, value) => mapper(key, value, object);
+
 	return _mapObject(object, mapperWithRoot, options);
 }
diff --git a/readme.md b/readme.md
@@ -47,7 +47,7 @@ Type: `(sourceKey, sourceValue, source) => [targetKey, targetValue, mapperOption
 A mapping function.
 
 > [!NOTE]
-> When `options.deep` is `true`, the mapper can receive keys and values from nested objects and arrays. In that case, the mapper parameters are intentionally widened: `sourceKey` is typed as `string` and `sourceValue` as `unknown`, reflecting the actual runtime behavior when recursing into unknown shapes. The third argument `source` is always the original input object, not the current nested owner.
+> When `options.deep` is `true`, the mapper receives keys and values from nested objects and arrays. The `sourceKey` parameter is typed as `string` and `sourceValue` as `unknown` to reflect the actual runtime behavior when recursing into unknown shapes. The third argument `source` is always the original input object, not the current nested owner.
 
 ##### mapperOptions
 
@@ -73,6 +73,8 @@ Default: `false`
 
 Recurse nested objects and objects in arrays.
 
+Built-in objects like `RegExp`, `Error`, `Date`, and `Blob` are not recursed into. Special objects like Jest matchers are also automatically excluded.
+
 ##### target
 
 Type: `object`\
diff --git a/test.js b/test.js
@@ -215,3 +215,62 @@ test('remove keys (#36)', t => {
 	const actual = mapObject(object, mapper, {deep: true});
 	t.deepEqual(actual, expected);
 });
+
+test('should not recurse into Jest-like matchers', t => {
+	// Mock a Jest asymmetric matcher like expect.anything()
+	const jestMatcher = {
+		$$typeof: Symbol.for('jest.asymmetricMatcher'),
+		asymmetricMatch: () => true,
+		toString: () => 'expect.anything()',
+	};
+
+	const input = {
+		normal: {nested: 'value'},
+		matcher: jestMatcher,
+	};
+
+	let calls = 0;
+	const result = mapObject(input, (key, value) => {
+		calls++;
+		// Should not recurse into jestMatcher properties
+		t.not(key, '$$typeof');
+		t.not(key, 'asymmetricMatch');
+		t.not(key, 'toString');
+		return [key, value];
+	}, {deep: true});
+
+	t.is(result.matcher, jestMatcher);
+	t.is(result.normal.nested, 'value');
+	t.is(calls, 3); // 'normal', 'nested', 'matcher'
+});
+
+test('options object is not mutated', t => {
+	const options = {deep: true, target: {}};
+	const originalOptions = {...options};
+
+	mapObject({a: 1}, (key, value) => [key, value], options);
+
+	t.deepEqual(options, originalOptions);
+});
+
+test('built-in objects are not recursed into', t => {
+	const date = new Date();
+	const regex = /test/;
+	const error = new Error('test');
+
+	const input = {
+		date,
+		regex,
+		error,
+		normal: {nested: 'value'},
+	};
+
+	const calls = [];
+	mapObject(input, (key, value) => {
+		calls.push(key);
+		return [key, value];
+	}, {deep: true});
+
+	// Should visit top-level keys and nested normal object
+	t.deepEqual(calls.sort(), ['date', 'error', 'nested', 'normal', 'regex']);
+});
