js: fix core.Object, output order, static const fields

lib/runtime/dart_runtime.js

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 var dart;
 (function (dart) {
   var defineProperty = Object.defineProperty;
   var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
   var getOwnPropertyNames = Object.getOwnPropertyNames;
 
@@ skipping 182 matching lines @@
    * previous entries.
    *
    * For each mixin, we only take its own properties, not anything from its
    * superclass (prototype).
    */
   function mixin(base/*, ...mixins*/) {
     // Inherit statics from Base to simulate ES6 class inheritance
     // Conceptually this is: `class Mixin extends base {}`
     function Mixin() {
       // TODO(jmesserly): since we're using initializers and not constructors,
-      // we can just skip directly to dart.Object.
-      dart.Object.apply(this, arguments);
+      // we can just skip directly to core.Object.
+      core.Object.apply(this, arguments);
     }
     Mixin.__proto__ = base;
     Mixin.prototype = Object.create(base.prototype);
     Mixin.prototype.constructor = Mixin;
     // Copy each mixin, with later ones overwriting earlier entries.
     var mixins = Array.prototype.slice.call(arguments, 1);
     for (var i = 0; i < mixins.length; i++) {
       copyProperties(Mixin.prototype, mixins[i].prototype);
     }
     // Create an initializer for the mixin, so when derived constructor calls
@@ skipping 119 matching lines @@
   /**
    * Implements Dart constructor behavior. Because of V8 `super` [constructor
    * restrictions](https://code.google.com/p/v8/issues/detail?id=3330#c65) we
    * cannot currently emit actual ES6 constructors with super calls. Instead
    * we use the same trick as named constructors, and do them as instance
    * methods that perform initialization.
    */
   // TODO(jmesserly): we'll need to rethink this once the ES6 spec and V8
   // settles. See <https://github.com/dart-lang/dart-dev-compiler/issues/51>.
   // Performance of this pattern is likely to be bad.
-  dart.Object = function Object() {
+  core.Object = function Object() {
     // Get the class name for this instance.
     var name = this.constructor.name;
     // Call the default constructor.
     var init = this[name];
     var result = void 0;
     if (init) result = init.apply(this, arguments);
     return result === void 0 ? this : result;
   };
-  // The initializer for dart.Object
-  dart.Object.prototype.Object = function() {};
-  dart.Object.prototype.constructor = dart.Object;
+  // The initializer for Object
+  core.Object.prototype.Object = function() {};
+  core.Object.prototype.constructor = core.Object;
 
 })(dart || (dart = {}));