fix(isMatch): handle primitive targets with object source patterns correctly

benchmarks/bundle-size/find.spec.ts

@@ -9,6 +9,6 @@ describe('find bundle size', () => {
 
   it('es-toolkit/compat', async () => {
     const bundleSize = await getBundleSize('es-toolkit/compat', 'find');
-    expect(bundleSize).toMatchInlineSnapshot(`8708`);
+    expect(bundleSize).toMatchInlineSnapshot(`8772`);
   });
 });

benchmarks/bundle-size/findKey.spec.ts

@@ -14,6 +14,6 @@ describe('findKey bundle size', () => {
 
   it('es-toolkit/compat', async () => {
     const bundleSize = await getBundleSize('es-toolkit/compat', 'findKey');
-    expect(bundleSize).toMatchInlineSnapshot(`8373`);
+    expect(bundleSize).toMatchInlineSnapshot(`8437`);
   });
 });

benchmarks/bundle-size/mapKeys.spec.ts

@@ -14,6 +14,6 @@ describe('mapKeys bundle size', () => {
 
   it('es-toolkit/compat', async () => {
     const bundleSize = await getBundleSize('es-toolkit/compat', 'mapKeys');
-    expect(bundleSize).toMatchInlineSnapshot(`8386`);
+    expect(bundleSize).toMatchInlineSnapshot(`8450`);
   });
 });

benchmarks/bundle-size/mapValues.spec.ts

@@ -14,6 +14,6 @@ describe('mapValues bundle size', () => {
 
   it('es-toolkit/compat', async () => {
     const bundleSize = await getBundleSize('es-toolkit/compat', 'mapValues');
-    expect(bundleSize).toMatchInlineSnapshot(`8386`);
+    expect(bundleSize).toMatchInlineSnapshot(`8450`);
   });
 });

src/compat/predicate/isMatch.spec.ts

@@ -63,7 +63,7 @@
 
     const Foo = function Foo(this: Foo) {
       this.a = 1;
     } as any as FooConstructor;
 
     Foo.prototype.b = 2;
 
@@ -83,7 +83,7 @@
 
     const Foo = function Foo(this: Foo) {
       this.a = 1;
     } as any as FooConstructor;
 
     Foo.prototype.b = 2;
 
@@ -153,7 +153,7 @@
 
     const Foo = function Foo(this: Foo, object: Partial<Foo>) {
       Object.assign(this, object);
     } as any as FooConstructor;
 
     // eslint-disable-next-line
     // @ts-ignore
@@ -288,16 +288,16 @@
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-expect-error
       expect(isMatch(1, { b: undefined })).toBe(true);
     } catch (e: any) {
       expect(false, e.message);
     }
 
     try {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-expect-error
       expect(isMatch(1, { a: 1, b: undefined })).toBe(true);
     } catch (e: any) {
       expect(false, e.message);
     }
 
     // eslint-disable-next-line
@@ -307,8 +307,8 @@
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-expect-error
       expect(isMatch(1, { a: { c: undefined } })).toBe(true);
     } catch (e: any) {
       expect(false, e.message);
     }
 
     // eslint-disable-next-line
@@ -387,4 +387,45 @@
       )
     ).toBe(false);
   });
+
+  it('should not match nested empty object patterns against non-object targets', () => {
+    expect(isMatch({ value: 'bar' }, { value: {} })).toBe(false);
+    expect(isMatch({ value: 123 }, { value: {} })).toBe(false);
+    expect(isMatch({ value: true }, { value: {} })).toBe(false);
+    expect(isMatch({ value: null }, { value: {} })).toBe(false);
+    expect(isMatch({ value: undefined }, { value: {} })).toBe(false);
+    expect(isMatch({ value: [] }, { value: {} })).toBe(false);
+    expect(isMatch({ value: new Date(0) }, { value: {} })).toBe(false);
+    expect(isMatch({ value: { b: 1 } }, { value: {} })).toBe(true);
+  });
+
+  it('should not match nested object patterns against non-plain-object targets', () => {
+    expect(isMatch({ value: [1, 2, 3] }, { value: { 0: 1 } })).toBe(false);
+    expect(isMatch({ value: /a/ }, { value: { source: 'a' } })).toBe(false);
+    expect(isMatch({ value: new String('bar') }, { value: { length: 3 } })).toBe(false);
+  });
+
+  it('should match object patterns against primitive targets at the top level', () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(isMatch('bar', {})).toBe(true);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(isMatch('bar', { length: 3 })).toBe(true);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(isMatch('bar', { 0: 'b' })).toBe(true);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(isMatch('bar', { length: 4 })).toBe(false);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(isMatch('bar', { anyKey: undefined })).toBe(false);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(isMatch(123, { anyKey: undefined })).toBe(false);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(isMatch(true, { anyKey: undefined })).toBe(false);
+  });
 });

src/compat/predicate/isMatchWith.spec.ts

@@ -11,7 +11,7 @@
 describe('isMatchWith', () => {
   it('should provide correct `customizer` arguments', () => {
     const argsList: unknown[] = [];
     const object1: any = { a: [1, 2], b: null };
     const object2: any = { a: [1, 2], b: null };
 
     object1.b = object2;
@@ -341,6 +341,12 @@
     expect(isMatchWith({ a: { b: 2 } }, { a: 1 }, () => undefined)).toBe(false);
   });
 
+  it('should not match nested empty object patterns against non-object targets', () => {
+    expect(isMatchWith({ value: 'bar' }, { value: {} }, () => undefined)).toBe(false);
+    expect(isMatchWith({ value: [] }, { value: {} }, () => undefined)).toBe(false);
+    expect(isMatchWith({ value: { b: 1 } }, { value: {} }, () => undefined)).toBe(true);
+  });
+
   it('should handle empty collections', () => {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error

src/compat/predicate/isMatchWith.ts

@@ -1,6 +1,8 @@
 import { isObject } from './isObject.ts';
 import { isPrimitive } from '../../predicate/isPrimitive.ts';
+import { getTag } from '../_internal/getTag.ts';
 import type { IsMatchWithCustomizer } from '../_internal/IsMatchWithCustomizer.ts';
+import { argumentsTag, objectTag } from '../_internal/tags.ts';
 import { eq } from '../util/eq.ts';
 
 /**
@@ -46,7 +48,8 @@ export function isMatchWith(target: object, source: object, compare: IsMatchWith
  * - **Primitives**: Matches using strict equality
  *
  * Special cases:
- * - Empty objects, arrays, Maps, and Sets always match any target
+ * - Empty arrays, Maps, and Sets always match any target
+ * - An empty object matches any target at the top level, but at nested levels it only matches object targets
  * - `null` and `undefined` source values have specific matching rules
  * - Circular references are handled using an internal stack to prevent infinite recursion
  *
@@ -151,7 +154,7 @@ function isMatchWithInternal(
 
   switch (typeof source) {
     case 'object': {
-      return isObjectMatch(target, source, compare, stack);
+      return isObjectMatch(target, source, compare, stack, isRoot);
     }
     case 'function': {
       const sourceKeys = Object.keys(source);
@@ -191,7 +194,8 @@ function isObjectMatch(
     source: any,
     stack?: Map<any, any>
   ) => boolean | undefined,
-  stack: Map<any, any> | undefined
+  stack: Map<any, any> | undefined,
+  isRoot = false
 ): boolean {
   if (source == null) {
     return true;
@@ -211,8 +215,21 @@ function isObjectMatch(
 
   const keys = Object.keys(source as any);
 
-  if (target == null || isPrimitive(target)) {
-    return keys.length === 0;
+  if (target == null) {
+    return isRoot && keys.length === 0;
+  }
+
+  if (isRoot) {
+    if (isPrimitive(target)) {
+      target = Object(target);
+    }
+  } else {
+    // Nested object patterns only match plain object-like targets, like lodash's tag comparison.
+    const tag = getTag(target);
+
+    if (tag !== objectTag && tag !== argumentsTag) {
+      return false;
+    }
   }
 
   if (keys.length === 0) {
@@ -229,7 +246,7 @@ function isObjectMatch(
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
 
-      if (!isPrimitive(target) && !(key in target)) {
+      if (!(key in target)) {
         return false;
       }
 

src/compat/predicate/matches.spec.ts

@@ -28,6 +28,11 @@ describe('matches', () => {
     expect(matches({ a: 1 })({ a: { b: 2 } })).toBe(false);
   });
 
+  it('should not match nested empty object patterns against non-object targets', () => {
+    expect(matches({ value: {} })({ value: 'bar' })).toBe(false);
+    expect(matches({ value: {} })({ value: { b: 1 } })).toBe(true);
+  });
+
   it(`should match inherited string keyed \`object\` properties`, () => {
     interface Foo {
       a: number;