More examples:

• RxJS went from Methods to HOF.
• Angular team tells me they write their API in a weird way in order to be tree-shakable, though they don't like that they have to do that.
• Zod library is method-based, and Valibot was created as a tree-shakable alternative.
• _.chain from Lodash is method-based, but they of course export a whole separate library of tree-shakable functions also for people who want that.
• Colors (by Lea Verou) has an OO-methods-based API but it's huge so they export a separate set of functions that are more tree-shakable.

So yes, I see a strong and consistent trend of people having method-based APIs then needing to back out and switch to function-based APIs for tree-shaking / performance.

The idea was that you could have a Slice class and an Index class that supported these symbols, and that you could use x:y literal syntax to produce a Slice and ^x syntax to produce an Index computed from the end of an array, such that the following are equivalent:

myArr[0:1];
myArr[new Slice(0, 1)];
new Slice(0, 1)[Symbol.geti](myArr);

myArr[^1];
myArr[new Index(1, true /*fromEnd*/)];
new Index(1, true)[Symbol.geti](myArr);

A Symbol.geti for a function could just be a call to bind:

myArr[Array.prototype.slice](1, 2);
Array.prototype.slice[Symbol.geti](myArr)(1, 2);
Array.prototype.slice.bind(myArr)(1, 2);

Or a possible Symbol.calli could intercept invocation:

myArr[Array.prototype.slice](1, 2);
Array.prototype.slice[Symbol.calli](myArr, 1, 2);

But this could be as simple as a wrapper function. i.e., if we had Symbol.geti already, someone could just write:

const wrap = f => ({ [Symbol.geti]: obj => f.bind(obj) });

myArr[wrap(Array.prototype.slice)](1, 2);

class C {
  #x = Math.random();
  #y = Math.random();
}

extends C {
  length() {
    return Math.sqrt(this.#x**2 + this.#y**2);
  }
}

console.log(new C()..length())

E.g.

import {C} from '...';

extends C {
  length() { this.#x } // lol no, syntax error, go away
}

If you're in the same scope, you don't need those if we already have static {}:

let getX;
class C {
  x = ...;
  static { getX = c => c.#x; }
}

C.prototype.length = function () { return getX(this); };