DOM access is inherently megamorphic. This perf-tests attempts to prove that caching the methods on the DOM and invoking them using .call() is faster than using the megamorphic property lookup.

    // Cache the getter only once.
    const Node_parentNode_getter = Object.getOwnPropertyDescriptor(Node.prototype, 'parentNode').get;

    Node_parentNode_getter.call(domNode); // Is the fastest way to access DOM.
    domNode.parentNode; // is megamorphic and hence slower than the line above.
  

This approach seems to hold in all browser (except for chrome due to issue 8820).

Further reading:

• What's up with monomorphism?
• Javascript Hidden Classes and Inline Caching in V8
• Issue 8820: Improve native accessor performance (for DOM accessors)

profiling...

• OBJ_* Measurement done on regular Javascript object.
• DOM_* Measurement done on DOM Element. (Because DOM elements are C++ so different rules may apply)
• *_mono: Cost of doing a monomorphic property access obj.increment(1) where obj always has same shape.
• *_mega: Cost of doing a megamorphic property access obj.increment(1) where obj always has different shape.
• *_call: Cost of doing a property access using Foo.prototype.increment.call(instance) where obj always has different shape.
• *_mega/*-mono: Ratio of how much slower the megamorphic case is than monomorphic (inline cache)
• *_mega/*-mono: Ratio of how much slower the megamorphic case is than monomorphic (inline cache)