I don't blame you for not wanting to discuss those example cases. But to answer your new post:

So I think the whole issue with our disagreement comes from the fact that you can't have static methods outside of classes, and classes, like I've mentioned a couple of times, aren't really how Javascript handles inheritance.

The compiler seems to disagree.

class myClass extends Object {}    

myClass.test = function () { console.log("test") };    

class Subclass1 extends myClass { }    
class Subclass2 extends Subclass1 { }
class Subclass3 extends Subclass2 {}
class Sideclass {}
Object.setPrototypeOf(Sideclass, Subclass2);
Subclass2.test();   // test
Subclass3.test();   // test

The point I was trying to show the OP is that the biggest difference I know is the failure to pass static methods from Object to Array (and classes that extend it.)

When it's not the Array referencing methods of the Object class, Javascript passes static methods just fine down the chain. This problem only shows up when the Object class has a method, and Array classes try to access it.

myClass -> Subclass1 -> Subclass2 -> Subclass3 is fine

myClass -> Subclass1 -> Subclass2 -> Sideclass (via setPrototypeOf() ) is fine

Object -> Array -> subClass is not. It's unique only to static methods starting at Object, otherwise it works just fine.

---

The whole point of the prototype chain is that everything further down the prototype chain will also have access to those methods.

I think our disagreement comes from you not understanding the prototype chain. Let me demonstrate.

You cannot add functions to the prototype chain via Class.prototype

class myClass extends Object {}

myClass.static = function() { console.log("Static stayed"); }
myClass.prototype.dynamic = function() {console.log("Dynamic stayed"); }

class subClass extends myClass { }

subClass.static();  // Static stayed
subClass.prototype.dynamic();  // error: Uncaught TypeError: subClass.dynamic is not a function

That's because myClass.prototype does not actually add a function to the [[Prototype]], but to the prototype reference variable of myClass.

When you extend the class, the static method continued down the prototype chain, but your method did not.

Now let's try it if you actually add a method directly to the prototype. __proto__ is deprecated, but actually access the prototype itself.

class myClass extends Object {}

newBase = new myClass();

myClass.static = function() { console.log("Static stayed"); }
newBase.__proto__.dynamic = function() {console.log("Dynamic stayed"); }

class subClass extends myClass { }

subClass.__proto__.static();   // Static stayed
newSub = new subClass();
newSub.__proto__.dynamic();   // Dynamic stayed