Here's an even cleaner solution: provide an ES API function that allows a caller to disable other builtin API functions. By disable, I mean replace them with undefined or a function that throws.
globalThis.disableAPI(owner, fnName) {
let retval = owner.prototype[fnName];
function disabledFn() {
throw new ReferenceError(`This function ('${fnName}') has been disabled.`);
}
function isOriginal(fn) {
return !fn.name.startsWith('bound ') && fn.toString().endsWith('{ [native code] }');
}
Object.defineProperty(disabledFn, Symbol.disabled, { value: true });
if (isOriginal(owner) && isOriginal(retval)) {
owner.prototype = disabledFn;
}
else {
retval = undefined;
}
return retval;
}
Something like this implemented in engine would disable the call for all successive callers. The catch is that it would have to work in concert with something like 'use initial' such that use initial would not be allowed to return the original of such disabled functions. It would do so by checking if Symbol.disabled has been set on the method. This not only gives the engine a simple, shim-able way of disabling methods, but also gives developers a way of doing the same for registered APIs under my alternative approach.
Regardless, the approach for denying access to ES API built-ins should be something generic. It should probably have a proposal all its own and be applicable regardless of any new feature added. BTW, I set it so the disableAPI function returns the original of the function that was disabled. This way the caller still has access to the function if desired.