Class methods in the sources should be excluded from the resulting type of `Object.entries`

[graphemecluster]

Issue #56 made me think of other problems regarding the current typing of Object.entries. It might be a good chance to address them altogether.

As you know, Object.entries only copies own properties, so besides function signatures, class methods from the sources shouldn't be included in the resulting type too:

const foo = {
    method() {},
    funcProp: () => {},
};
Object.assign({}, foo); // { method, funcProp }

class Foo {
    method() {}
    funcProp = () => {};
}
Object.assign({}, new Foo()); // { funcProp }

But it's hard to determine whether a function in a class is a method or a function property. Since methods are bivariant while function properties are contravariant in TypeScript, it should be possible to distinguish between them by some tricks that determine the variance of a function, but I didn't manage to come up with a solution, so I've posted this issue instead of a PR.

As its usage seems rare, I'm not sure if it's worth spending the time to find a solution.

[graphemecluster]

Of course it still won’t cover all the edge cases, say if there is a line this.method = this.method.bind(this); in the class constructor, or if someone defines a non-enumerable property with Object.defineProperty().

[graphemecluster]

Another problem I would like to bring up is that primitives are currently permitted. While ECMAScript does allow them, passing them as arguments is likely unintended, especially at source positions. It might be worth forbidding them while still allowing objects, null and undefined.

[graphemecluster]

For the second problem, a more lenient solution is to type Object.assign like:

declare function assign<
  T extends (Options extends { allowPrimitives: true } ? {} : object),
  Ts extends readonly (Options extends { allowPrimitives: true } ? unknown : object | null | undefined)[],
  Options extends { allowPrimitives: boolean } = { allowPrimitives: false }
>(
  target: T,
  ...sources: Ts
): T & Intersect<Ts>;

But there are 2 defects:

1. Users will have to write out the remaining type arguments explicitly if they want primitives, since TypeScript infers either all or none of the type arguments. This is true even if I put Options before T and Ts;
2. If we were to go with this style, other current declarations will need to be updated to stick with this style too. That will be きりがない.