Insert semicolon after class definition with no constructor.

Previously:

Main = function () { }

now:

Main = function () { };
Dont avoid semicolon insertion after static field gen.

Previously, class Main { static function main() {} } generated:

Main.main = function () {
}

instead of (now):

Main.main = function () {
};
Change inherit to Inherit in $extend implementation, removing semicolon.

Both these are further common js warnings by linters.
Ensure class prototype, when not using $extend has semicolon inserted.

Class.prototype = {
    ..
}; <--
Ensure semicolon is inserted after package declaration.

var js = {}; <--

for package js;
Move ',' in field seperator to previous line.

{
    x : ..,
    y : ..,
    z : ..
}

instead of:

{
    x : ..
    ,y : ..
    ,z : ..
}

(Another jshint et. al warning)
Remove semicolon after $iterator and $bind implementations.

Unnecessary, and another jshint et. al warning.
Insert semicolons after enum definitions and function constructors.
Remove redundant space at end of __js__ block in string_rec

Unecessary, and causes a redundant ; to be inserted in generated js.
Add @:shallowExpose meta.

@:shallowExpose works very similarly to @:expose, but instead of
exposing on the window object (or export for nodejs), the class or
static field is instead exposed only to the surrounding scope of
the js_modern generated Haxe closure.

These are different things, when the Haxe generated code is used as
one part of a larger JS project with where in my particular use-case;
all JS code (including haxe generated code) is compiled into a single
optimised and minified JS file wrapped in a large closure, in this case
I do not wish the Haxe types to be exposed to window, but only to this
large closure containing the other JS code using the Haxe types,
the @:shallowExpose permits that.

Example:

@:shallowExpose class A {}
@:shallowExpose class B {}
@:shallowExpose("x.y.D") class D {}
@:shallowExpose("x.C") class C {}

class E {
        @:shallowExpose static function e() {}
}

Generates:

var $__hx_shallows = {E:{},x:{y:{}}};
(function () { "use strict";
var A = $__hx_shallows.A = function() { };
var B = $__hx_shallows.B = function() { };
var D = $__hx_shallows.x.y.D = function() { };
var C = $__hx_shallows.x.C = function() { };
var E = function() { };
E.e = $__hx_shallows.E.e = function() {
};
...
})();
var E = {};
var x = {y:{}};
var A = $__hx_shallows.A;
var B = $__hx_shallows.B;
x.y.D = $__hx_shallows.x.y.D;
x.C = $__hx_shallows.x.C;
E.e = $__hx_shallows.E.e;
seperator -> separator, revert e920e98.
Move to unified @:expose with -D shallow-expose
sync libs
added --display memory with scanned module size and leaks
fixed memory leak dependency reporting (was wrong)
separate UInt from StdTypes (got dependency to String/Std with new abtract)
always make modules dependent from StdTypes
ensure that StdTypes does not get wrong dependencies when using hide_types()
print more leaks by default, added verbose mode (-v) to print cache dependencies
ensure that all modules properly depend on String and Array
fixed dependency leak with global using