Implement Function.prototype.bind, including new

Writing a bind that fixes this and prepends arguments takes three lines. The reason this is an interview favourite is the other half of the spec: a bound function used as a constructor must ignore the bound receiver entirely, because new supplies its own this, and instances must still be instanceof the original function.

Implement myBind(fn, thisArg, ...boundArgs), where fn is an ordinary function declared with the function keyword. It returns a new function that, when called normally, invokes fn with this set to thisArg and with boundArgs followed by the call-time arguments, returning fn's result. The bound receiver wins permanently: calling the bound function as a method of some other object does not change this inside fn. When the bound function is called with new, thisArg is ignored and this inside fn is the newly constructed object; boundArgs are still prepended, the result is the new object (assuming fn returns nothing), the object inherits from fn.prototype so methods defined there are available, and instance instanceof fn is true. Your implementation must not use Function.prototype.bind, call or apply: one of the tests replaces all three with functions that throw.

function greet(greeting) { return greeting + ", " + this.name; }

const hiAda = myBind(greet, { name: "Ada" }, "Hi");
hiAda(); // "Hi, Ada"

function Point(x, y) { this.x = x; this.y = y; }
Point.prototype.sum = function () { return this.x + this.y; };

const BoundPoint = myBind(Point, null, 1);
const p = new BoundPoint(2);

p.x;                    // 1
p.y;                    // 2
p.sum();                // 3 — prototype methods still work
p instanceof Point;     // true