Generate tree-shakeable Typescript code

Quick refresher on tree-shaking:

export const foo = () => ...
export const bar = () => ...

when referenced with

import { foo } from 'blah';

foo();

will generate

const foo = () => ...
foo();

while

export class Blah {
    function foo() { ... }
    function bar() { ... }
}

when referenced with

import { Blah } from 'blah';

Blah.foo();

will generate

class Blah {
    function foo() { ... }
    function bar() { ... }
}
Blah.foo();

Currently, MemoryPack generates the latter. Meaning, if I only need the serialize() function, the entire class gets bundled anyway. Lots of code that I have no use for.

Additionally, classes get bundled pretty much as-is, while interfaces could be stripped away at bundle time.

For maximum tree-shaking compatibility and minimum bundle sizes, MemoryPack should be generating interfaces and loose functions, for example

export interface Person {
    name: string;
    surname: string;
    shoeSize: number;
    birthday: Date;
}

export function serialize(value: Person | null): Uint8Array {
    // snip...
}

export function deserialize(buffer: ArrayBuffer): Person | null {
    // snip...
}

The issue names no files, tests, or generator entry point; begin by locating the code that emits the current TypeScript classes and comparing its output with the examples. Done means generated output uses interfaces and separately exported serialize/deserialize functions, with unused code removable by tree-shaking; add or run the relevant generator checks once their location is identified.