Now, there are many, many many things that we did to bring our video player source code to its svelte ~25k, but one of the techniques was to be extremely precise in scope for our class methods. Above you can see some stubbed-out code that illustrates the three different types of class methods we used: Private, Privileged, and Public.
Note: this goes for variables too. Private variables will compress better than declaring a variable on your class object. If the variable doesn't need to be accessed from outside your class, just declare it inside your init method.
Private methods sound great, but sometimes you really do need access to a method from outside a class or you might need to override a super method, and that's where public methods come in. Public methods are methods declared on your Class object itself. Because the function can be called from anywhere, it's likely that Closure will not compress these method names down, so try to keep them short and sweet and use them sparingly.
There is one other downside to public methods and it shows up if you followed the advice in the note above and started declaring most of your variables as locally scoped within your init method: you don't have access to those variables in any other method other than the init! Well, that sucks! You may very well need that variable, and you shouldn't have to sacrifice the advantage of locally scoped variables just to gain access. Privileged methods to the rescue!
Privileged methods behave like public methods in that they can be called from outside your Class, but they have one huge advantage: since they're defined within your init method, they get access to all your local variables; you get the benefits of locally scoped variables which you then still get access to from outside your class (leading to some pretty powerful stuff).
Of course there are still some disadvantages; privileged methods aren't completely magical, and since they're accessed externally Closure tends to not compress its names. Also, if you're using inheritance for Classes, you'll only be able to override privileged methods and not get access to their super method.
And that's my quick overview of a relatively simple pattern that, if used correctly (ie. use local scope as much as humanly possible), should be able to shave some bytes here and there. If you have any suggestions for awesome ideas to add to this pattern (or if I've said something completely wrong, which I've been known to do in the past) let's get a discussion going in the comments.