There are a couple of ways:

1. Object.prototype.hasOwnProperty.call(map, "one").

2. The brand-new Object.hasOwn(map, "one"), if your target environments support it (it's easily polyfilled if not), which was added precisely because of this issue.

Example:

let map = {one: true, two: true, hasOwnProperty: true};

console.log(
    "Object.prototype.hasOwnProperty.call:", 
    Object.prototype.hasOwnProperty.call(map, "one")
);
if (Object.hasOwn) {
    console.log("Object.hasOwn:", Object.hasOwn(map, "one"));
} else {
    console.log("Object.hasOwn not supported in this environment yet");
}

There are also some methods on Reflect that are useful for these things, such as Reflect.getOwnPropertyDescriptor (Object has a similar method), which would return an object that had value: true on it (because one is a data property, not an accessor property).

Note that, unfortunately, even these static methods can be replaced, so at some point you just have to trust that the environment isn't actively set up to lie to you. :-) For what it's worth, here's an example of a compromised environment:

let map = {one: true, two: true, hasOwnProperty: true};

console.log("Setting up the lies");
const originalHasOwnProperty = Object.prototype.hasOwnProperty;
const originalHasOwn = Object.hasOwn;

Object.prototype.hasOwnProperty = function(propName) {
    if (this === map && propName === "one") {
        return false; // lie
    }
    return originalHasOwnProperty.call(this, propName);
};

Object.hasOwn = function(obj, propName) {
    if (obj === map && propName === "one") {
        return false; // lie
    }
    return originalHasOwn.call(Object, obj, propName);
};

console.log(
    "Object.prototype.hasOwnProperty.call:", 
    Object.prototype.hasOwnProperty.call(map, "one")
);
if (Object.hasOwn) {
    console.log("Object.hasOwn:", Object.hasOwn(map, "one"));
} else {
    console.log("Object.hasOwn not supported in this environment yet");
}

Detecting modifications of the original methods can be complex, so if you decide to try to do that, look for well-researched solutions with solid-looking citations. Normally, though, it's overkill. I note it here just for completeness.

You can use apply

const map = {one: true, two: true, hasOwnProperty: true};
console.log(Object.hasOwnProperty.apply(map,[ "one"]));

or call

const map = {one: true, two: true, hasOwnProperty: true};
console.log(Object.hasOwnProperty.call(map,"one"));

or bind

const map = {one: true, two: true, hasOwnProperty: true};
console.log(Object.hasOwnProperty.bind(map)('one'));

One suggestion : hasOwnProperty is really a bad property name.

But still if you want to work with it. There are few ways to achieve this :

• By using Object.hasOwn()

  let map = {one: true, two: true, hasOwnProperty: true};
  
  console.log(Object.hasOwn(map, "one")); // true

• By using Object.prototype.hasOwnProperty.call()

  let map = {one: true, two: true, hasOwnProperty: true};
  
  console.log(Object.prototype.hasOwnProperty.call(map, "one")); // true