qualify core types: Object, Error, Symbol

lib/runtime/dart/core.js

 dart_library.library('dart/core', null, /* Imports */[
   "dart_runtime/dart"
 ], /* Lazy imports */[
   'dart/_js_helper',
   'dart/_internal',
   'dart/collection',
   'dart/_interceptors',
   'dart/convert'
 ], function(exports, dart, _js_helper, _internal, collection, _interceptors, convert) {
   'use strict';
   let dartx = dart.dartx;
-  class Object {
-    constructor() {
-      let name = this.constructor.name;
-      let result = void 0;
-      if (name in this)
-        result = this[name](...arguments);
-      return result === void 0 ? this : result;
+  exports.Object = (() => {
+    class Object {
+      constructor() {
+        let name = this.constructor.name;
+        let result = void 0;
+        if (name in this)
+          result = this[name](...arguments);
+        return result === void 0 ? this : result;
+      }
+      ['=='](other) {
+        return identical(this, other);
+      }
+      get hashCode() {
+        return _js_helper.Primitives.objectHashCode(this);
+      }
+      toString() {
+        return _js_helper.Primitives.objectToString(this);
+      }
+      noSuchMethod(invocation) {
+        dart.throw(new NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments));
+      }
+      get runtimeType() {
+        return dart.realRuntimeType(this);
+      }
     }
-    ['=='](other) {
-      return identical(this, other);
-    }
-    get hashCode() {
-      return _js_helper.Primitives.objectHashCode(this);
-    }
-    toString() {
-      return _js_helper.Primitives.objectToString(this);
-    }
-    noSuchMethod(invocation) {
-      dart.throw(new NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments));
-    }
-    get runtimeType() {
-      return dart.realRuntimeType(this);
-    }
-  }
-  dart.setSignature(Object, {
-    constructors: () => ({Object: [Object, []]}),
-    methods: () => ({
-      '==': [bool, [dart.dynamic]],
-      toString: [String, []],
-      noSuchMethod: [dart.dynamic, [Invocation]]
-    })
-  });
-  class Deprecated extends Object {
+    dart.setSignature(Object, {
+      constructors: () => ({Object: [exports.Object, []]}),
+      methods: () => ({
+        '==': [bool, [dart.dynamic]],
+        toString: [String, []],
+        noSuchMethod: [dart.dynamic, [Invocation]]
+      })
+    });
+    return Object;
+  })();
+  class Deprecated extends exports.Object {
     Deprecated(expires) {
       this.expires = expires;
     }
     toString() {
       return `Deprecated feature. Will be removed ${this.expires}`;
     }
   }
   dart.setSignature(Deprecated, {
     constructors: () => ({Deprecated: [Deprecated, [String]]})
   });
-  class _Override extends Object {
+  class _Override extends exports.Object {
     _Override() {
     }
   }
   dart.setSignature(_Override, {
     constructors: () => ({_Override: [_Override, []]})
   });
   let deprecated = dart.const(new Deprecated("next release"));
   let override = dart.const(new _Override());
-  class _Proxy extends Object {
+  class _Proxy extends exports.Object {
     _Proxy() {
     }
   }
   dart.setSignature(_Proxy, {
     constructors: () => ({_Proxy: [_Proxy, []]})
   });
   let proxy = dart.const(new _Proxy());
   dart.defineExtensionNames([
     'toString'
   ]);
-  class bool extends Object {
+  class bool extends exports.Object {
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : false;
       dart.throw(new UnsupportedError('bool.fromEnvironment can only be used as a const constructor'));
     }
     toString() {
       return this ? "true" : "false";
     }
   }
   dart.setSignature(bool, {
     constructors: () => ({fromEnvironment: [bool, [String], {defaultValue: bool}]})
   });
   let Comparator$ = dart.generic(function(T) {
     let Comparator = dart.typedef('Comparator', () => dart.functionType(int, [T, T]));
     return Comparator;
   });
   let Comparator = Comparator$();
   let Comparable$ = dart.generic(function(T) {
-    class Comparable extends Object {
+    class Comparable extends exports.Object {
       static compare(a, b) {
         return a[dartx.compareTo](b);
       }
     }
     dart.setSignature(Comparable, {
       statics: () => ({compare: [int, [Comparable$(), Comparable$()]]}),
       names: ['compare']
     });
     return Comparable;
   });
   let Comparable = Comparable$();
-  class DateTime extends Object {
+  class DateTime extends exports.Object {
     DateTime(year, month, day, hour, minute, second, millisecond) {
       if (month === void 0)
         month = 1;
       if (day === void 0)
         day = 1;
       if (hour === void 0)
         hour = 0;
       if (minute === void 0)
         minute = 0;
       if (second === void 0)
@@ skipping 283 matching lines @@
   DateTime.MAY = 5;
   DateTime.JUNE = 6;
   DateTime.JULY = 7;
   DateTime.AUGUST = 8;
   DateTime.SEPTEMBER = 9;
   DateTime.OCTOBER = 10;
   DateTime.NOVEMBER = 11;
   DateTime.DECEMBER = 12;
   DateTime.MONTHS_PER_YEAR = 12;
   DateTime._MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
-  class num extends Object {
+  class num extends exports.Object {
     static parse(input, onError) {
       if (onError === void 0)
         onError = null;
       let source = input[dartx.trim]();
       num._parseError = false;
       let result = int.parse(source, {onError: num._onParseErrorInt});
       if (!dart.notNull(num._parseError))
         return result;
       num._parseError = false;
       result = double.parse(source, num._onParseErrorDouble);
@@ skipping 30 matching lines @@
   }
   dart.setSignature(double, {
     statics: () => ({parse: [double, [String], [dart.functionType(double, [String])]]}),
     names: ['parse']
   });
   double.NAN = 0.0 / 0.0;
   double.INFINITY = 1.0 / 0.0;
   double.NEGATIVE_INFINITY = -dart.notNull(double.INFINITY);
   double.MIN_POSITIVE = 5e-324;
   double.MAX_FINITE = 1.7976931348623157e+308;
-  let _duration = dart.JsSymbol('_duration');
-  class Duration extends Object {
+  let _duration = Symbol('_duration');
+  class Duration extends exports.Object {
     Duration(opts) {
       let days = opts && 'days' in opts ? opts.days : 0;
       let hours = opts && 'hours' in opts ? opts.hours : 0;
       let minutes = opts && 'minutes' in opts ? opts.minutes : 0;
       let seconds = opts && 'seconds' in opts ? opts.seconds : 0;
       let milliseconds = opts && 'milliseconds' in opts ? opts.milliseconds : 0;
       let microseconds = opts && 'microseconds' in opts ? opts.microseconds : 0;
       this._microseconds(dart.notNull(days) * dart.notNull(Duration.MICROSECONDS_PER_DAY) + dart.notNull(hours) * dart.notNull(Duration.MICROSECONDS_PER_HOUR) + dart.notNull(minutes) * dart.notNull(Duration.MICROSECONDS_PER_MINUTE) + dart.notNull(seconds) * dart.notNull(Duration.MICROSECONDS_PER_SECOND) + dart.notNull(milliseconds) * dart.notNull(Duration.MICROSECONDS_PER_MILLISECOND) + dart.notNull(microseconds));
     }
     _microseconds(duration) {
@@ skipping 124 matching lines @@
   Duration.MICROSECONDS_PER_MINUTE = dart.notNull(Duration.MICROSECONDS_PER_SECOND) * dart.notNull(Duration.SECONDS_PER_MINUTE);
   Duration.MICROSECONDS_PER_HOUR = dart.notNull(Duration.MICROSECONDS_PER_MINUTE) * dart.notNull(Duration.MINUTES_PER_HOUR);
   Duration.MICROSECONDS_PER_DAY = dart.notNull(Duration.MICROSECONDS_PER_HOUR) * dart.notNull(Duration.HOURS_PER_DAY);
   Duration.MILLISECONDS_PER_MINUTE = dart.notNull(Duration.MILLISECONDS_PER_SECOND) * dart.notNull(Duration.SECONDS_PER_MINUTE);
   Duration.MILLISECONDS_PER_HOUR = dart.notNull(Duration.MILLISECONDS_PER_MINUTE) * dart.notNull(Duration.MINUTES_PER_HOUR);
   Duration.MILLISECONDS_PER_DAY = dart.notNull(Duration.MILLISECONDS_PER_HOUR) * dart.notNull(Duration.HOURS_PER_DAY);
   Duration.SECONDS_PER_HOUR = dart.notNull(Duration.SECONDS_PER_MINUTE) * dart.notNull(Duration.MINUTES_PER_HOUR);
   Duration.SECONDS_PER_DAY = dart.notNull(Duration.SECONDS_PER_HOUR) * dart.notNull(Duration.HOURS_PER_DAY);
   Duration.MINUTES_PER_DAY = dart.notNull(Duration.MINUTES_PER_HOUR) * dart.notNull(Duration.HOURS_PER_DAY);
   Duration.ZERO = dart.const(new Duration({seconds: 0}));
-  class Error extends Object {
-    Error() {
+  exports.Error = (() => {
+    class Error extends exports.Object {
+      Error() {
+      }
+      static safeToString(object) {
+        if (dart.is(object, num) || typeof object == 'boolean' || null == object) {
+          return dart.toString(object);
+        }
+        if (typeof object == 'string') {
+          return exports.Error._stringToSafeString(object);
+        }
+        return exports.Error._objectToString(object);
+      }
+      static _stringToSafeString(string) {
+        return _js_helper.jsonEncodeNative(string);
+      }
+      static _objectToString(object) {
+        return _js_helper.Primitives.objectToString(object);
+      }
+      get stackTrace() {
+        return _js_helper.Primitives.extractStackTrace(this);
+      }
     }
-    static safeToString(object) {
-      if (dart.is(object, num) || typeof object == 'boolean' || null == object) {
-        return dart.toString(object);
-      }
-      if (typeof object == 'string') {
-        return Error._stringToSafeString(object);
-      }
-      return Error._objectToString(object);
-    }
-    static _stringToSafeString(string) {
-      return _js_helper.jsonEncodeNative(string);
-    }
-    static _objectToString(object) {
-      return _js_helper.Primitives.objectToString(object);
-    }
-    get stackTrace() {
-      return _js_helper.Primitives.extractStackTrace(this);
-    }
-  }
-  dart.setSignature(Error, {
-    constructors: () => ({Error: [Error, []]}),
-    statics: () => ({
-      safeToString: [String, [Object]],
-      _stringToSafeString: [String, [String]],
-      _objectToString: [String, [Object]]
-    }),
-    names: ['safeToString', '_stringToSafeString', '_objectToString']
-  });
-  class AssertionError extends Error {
+    dart.setSignature(Error, {
+      constructors: () => ({Error: [exports.Error, []]}),
+      statics: () => ({
+        safeToString: [String, [exports.Object]],
+        _stringToSafeString: [String, [String]],
+        _objectToString: [String, [exports.Object]]
+      }),
+      names: ['safeToString', '_stringToSafeString', '_objectToString']
+    });
+    return Error;
+  })();
+  class AssertionError extends exports.Error {
     AssertionError() {
       super.Error();
     }
   }
   class TypeError extends AssertionError {}
-  class CastError extends Error {
+  class CastError extends exports.Error {
     CastError() {
       super.Error();
     }
   }
-  class NullThrownError extends Error {
+  class NullThrownError extends exports.Error {
     NullThrownError() {
       super.Error();
     }
     toString() {
       return "Throw of null.";
     }
   }
-  let _hasValue = dart.JsSymbol('_hasValue');
-  class ArgumentError extends Error {
+  let _hasValue = Symbol('_hasValue');
+  class ArgumentError extends exports.Error {
     ArgumentError(message) {
       if (message === void 0)
         message = null;
       this.message = message;
       this.invalidValue = null;
       this[_hasValue] = false;
       this.name = null;
       super.Error();
     }
     value(value, name, message) {
@@ skipping 17 matching lines @@
         let result = "Invalid arguments(s)";
         if (this.message != null) {
           result = `${result}: ${this.message}`;
         }
         return result;
       }
       let nameString = "";
       if (this.name != null) {
         nameString = ` (${this.name})`;
       }
-      return `${this.message}${nameString}: ${Error.safeToString(this.invalidValue)}`;
+      return `${this.message}${nameString}: ${exports.Error.safeToString(this.invalidValue)}`;
     }
   }
   dart.defineNamedConstructor(ArgumentError, 'value');
   dart.defineNamedConstructor(ArgumentError, 'notNull');
   dart.setSignature(ArgumentError, {
     constructors: () => ({
       ArgumentError: [ArgumentError, [], [dart.dynamic]],
       value: [ArgumentError, [dart.dynamic], [String, String]],
       notNull: [ArgumentError, [], [String]]
     })
@@ skipping 71 matching lines @@
       if (name === void 0)
         name = null;
       if (message === void 0)
         message = null;
       if (dart.notNull(value) < 0)
         dart.throw(new RangeError.range(value, 0, null, name, message));
     }
     toString() {
       if (!dart.notNull(this[_hasValue]))
         return `RangeError: ${this.message}`;
-      let value = Error.safeToString(this.invalidValue);
+      let value = exports.Error.safeToString(this.invalidValue);
       let explanation = "";
       if (this.start == null) {
         if (this.end != null) {
           explanation = `: Not less than or equal to ${this.end}`;
         }
       } else if (this.end == null) {
         explanation = `: Not greater than or equal to ${this.start}`;
       } else if (dart.notNull(this.end) > dart.notNull(this.start)) {
         explanation = `: Not in range ${this.start}..${this.end}, inclusive.`;
       } else if (dart.notNull(this.end) < dart.notNull(this.start)) {
@@ skipping 34 matching lines @@
       super.value(invalidValue, name, message != null ? message : "Index out of range");
     }
     get start() {
       return 0;
     }
     get end() {
       return dart.notNull(this.length) - 1;
     }
     toString() {
       dart.assert(this[_hasValue]);
-      let target = Error.safeToString(this.indexable);
+      let target = exports.Error.safeToString(this.indexable);
       let explanation = `index should be less than ${this.length}`;
       if (dart.notNull(dart.as(dart.dsend(this.invalidValue, '<', 0), bool))) {
         explanation = "index must not be negative";
       }
       return `RangeError: ${this.message} (${target}[${this.invalidValue}]): ${explanation}`;
     }
   }
   IndexError[dart.implements] = () => [RangeError];
   dart.setSignature(IndexError, {
     constructors: () => ({IndexError: [IndexError, [int, dart.dynamic], [String, String, int]]})
   });
-  class FallThroughError extends Error {
+  class FallThroughError extends exports.Error {
     FallThroughError() {
       super.Error();
     }
   }
   dart.setSignature(FallThroughError, {
     constructors: () => ({FallThroughError: [FallThroughError, []]})
   });
-  let _className = dart.JsSymbol('_className');
-  class AbstractClassInstantiationError extends Error {
+  let _className = Symbol('_className');
+  class AbstractClassInstantiationError extends exports.Error {
     AbstractClassInstantiationError(className) {
       this[_className] = className;
       super.Error();
     }
     toString() {
       return `Cannot instantiate abstract class: '${this[_className]}'`;
     }
   }
   dart.setSignature(AbstractClassInstantiationError, {
     constructors: () => ({AbstractClassInstantiationError: [AbstractClassInstantiationError, [String]]})
   });
-  let _receiver = dart.JsSymbol('_receiver');
-  let _memberName = dart.JsSymbol('_memberName');
-  let _arguments = dart.JsSymbol('_arguments');
-  let _namedArguments = dart.JsSymbol('_namedArguments');
-  let _existingArgumentNames = dart.JsSymbol('_existingArgumentNames');
-  class NoSuchMethodError extends Error {
+  let _receiver = Symbol('_receiver');
+  let _memberName = Symbol('_memberName');
+  let _arguments = Symbol('_arguments');
+  let _namedArguments = Symbol('_namedArguments');
+  let _existingArgumentNames = Symbol('_existingArgumentNames');
+  class NoSuchMethodError extends exports.Error {
     NoSuchMethodError(receiver, memberName, positionalArguments, namedArguments, existingArgumentNames) {
       if (existingArgumentNames === void 0)
         existingArgumentNames = null;
       this[_receiver] = receiver;
       this[_memberName] = memberName;
       this[_arguments] = positionalArguments;
       this[_namedArguments] = namedArguments;
       this[_existingArgumentNames] = existingArgumentNames;
       super.Error();
     }
     toString() {
       let sb = new StringBuffer();
       let i = 0;
       if (this[_arguments] != null) {
         for (; dart.notNull(i) < dart.notNull(this[_arguments][dartx.length]); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
-          sb.write(Error.safeToString(this[_arguments][dartx.get](i)));
+          sb.write(exports.Error.safeToString(this[_arguments][dartx.get](i)));
         }
       }
       if (this[_namedArguments] != null) {
         this[_namedArguments].forEach(dart.fn((key, value) => {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(_symbolToString(key));
           sb.write(": ");
-          sb.write(Error.safeToString(value));
+          sb.write(exports.Error.safeToString(value));
           i = dart.notNull(i) + 1;
-        }, dart.dynamic, [Symbol, dart.dynamic]));
+        }, dart.dynamic, [exports.Symbol, dart.dynamic]));
       }
       if (this[_existingArgumentNames] == null) {
-        return `NoSuchMethodError : method not found: '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Arguments: [${sb}]`;
+        return `NoSuchMethodError : method not found: '${this[_memberName]}'\n` + `Receiver: ${exports.Error.safeToString(this[_receiver])}\n` + `Arguments: [${sb}]`;
       } else {
         let actualParameters = dart.toString(sb);
         sb = new StringBuffer();
         for (let i = 0; dart.notNull(i) < dart.notNull(this[_existingArgumentNames][dartx.length]); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(this[_existingArgumentNames][dartx.get](i));
         }
         let formalParameters = dart.toString(sb);
-        return "NoSuchMethodError: incorrect number of arguments passed to " + `method named '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Tried calling: ${this[_memberName]}(${actualParameters})\n` + `Found: ${this[_memberName]}(${formalParameters})`;
+        return "NoSuchMethodError: incorrect number of arguments passed to " + `method named '${this[_memberName]}'\n` + `Receiver: ${exports.Error.safeToString(this[_receiver])}\n` + `Tried calling: ${this[_memberName]}(${actualParameters})\n` + `Found: ${this[_memberName]}(${formalParameters})`;
       }
     }
   }
   dart.setSignature(NoSuchMethodError, {
-    constructors: () => ({NoSuchMethodError: [NoSuchMethodError, [Object, Symbol, List, Map$(Symbol, dart.dynamic)], [List]]})
+    constructors: () => ({NoSuchMethodError: [NoSuchMethodError, [exports.Object, exports.Symbol, List, Map$(exports.Symbol, dart.dynamic)], [List]]})
   });
-  class UnsupportedError extends Error {
+  class UnsupportedError extends exports.Error {
     UnsupportedError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this.message}`;
     }
   }
   dart.setSignature(UnsupportedError, {
     constructors: () => ({UnsupportedError: [UnsupportedError, [String]]})
   });
-  class UnimplementedError extends Error {
+  class UnimplementedError extends exports.Error {
     UnimplementedError(message) {
       if (message === void 0)
         message = null;
       this.message = message;
       super.Error();
     }
     toString() {
       return this.message != null ? `UnimplementedError: ${this.message}` : "UnimplementedError";
     }
   }
   UnimplementedError[dart.implements] = () => [UnsupportedError];
   dart.setSignature(UnimplementedError, {
     constructors: () => ({UnimplementedError: [UnimplementedError, [], [String]]})
   });
-  class StateError extends Error {
+  class StateError extends exports.Error {
     StateError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `Bad state: ${this.message}`;
     }
   }
   dart.setSignature(StateError, {
     constructors: () => ({StateError: [StateError, [String]]})
   });
-  class ConcurrentModificationError extends Error {
+  class ConcurrentModificationError extends exports.Error {
     ConcurrentModificationError(modifiedObject) {
       if (modifiedObject === void 0)
         modifiedObject = null;
       this.modifiedObject = modifiedObject;
       super.Error();
     }
     toString() {
       if (this.modifiedObject == null) {
         return "Concurrent modification during iteration.";
       }
-      return "Concurrent modification during iteration: " + `${Error.safeToString(this.modifiedObject)}.`;
+      return "Concurrent modification during iteration: " + `${exports.Error.safeToString(this.modifiedObject)}.`;
     }
   }
   dart.setSignature(ConcurrentModificationError, {
-    constructors: () => ({ConcurrentModificationError: [ConcurrentModificationError, [], [Object]]})
+    constructors: () => ({ConcurrentModificationError: [ConcurrentModificationError, [], [exports.Object]]})
   });
-  class OutOfMemoryError extends Object {
+  class OutOfMemoryError extends exports.Object {
     OutOfMemoryError() {
     }
     toString() {
       return "Out of Memory";
     }
     get stackTrace() {
       return null;
     }
   }
-  OutOfMemoryError[dart.implements] = () => [Error];
+  OutOfMemoryError[dart.implements] = () => [exports.Error];
   dart.setSignature(OutOfMemoryError, {
     constructors: () => ({OutOfMemoryError: [OutOfMemoryError, []]})
   });
-  class StackOverflowError extends Object {
+  class StackOverflowError extends exports.Object {
     StackOverflowError() {
     }
     toString() {
       return "Stack Overflow";
     }
     get stackTrace() {
       return null;
     }
   }
-  StackOverflowError[dart.implements] = () => [Error];
+  StackOverflowError[dart.implements] = () => [exports.Error];
   dart.setSignature(StackOverflowError, {
     constructors: () => ({StackOverflowError: [StackOverflowError, []]})
   });
-  class CyclicInitializationError extends Error {
+  class CyclicInitializationError extends exports.Error {
     CyclicInitializationError(variableName) {
       if (variableName === void 0)
         variableName = null;
       this.variableName = variableName;
       super.Error();
     }
     toString() {
       return this.variableName == null ? "Reading static variable during its initialization" : `Reading static variable '${this.variableName}' during its initialization`;
     }
   }
   dart.setSignature(CyclicInitializationError, {
     constructors: () => ({CyclicInitializationError: [CyclicInitializationError, [], [String]]})
   });
-  class Exception extends Object {
+  class Exception extends exports.Object {
     static new(message) {
       if (message === void 0)
         message = null;
       return new _ExceptionImplementation(message);
     }
   }
   dart.setSignature(Exception, {
     constructors: () => ({new: [Exception, [], [dart.dynamic]]})
   });
-  class _ExceptionImplementation extends Object {
+  class _ExceptionImplementation extends exports.Object {
     _ExceptionImplementation(message) {
       if (message === void 0)
         message = null;
       this.message = message;
     }
     toString() {
       if (this.message == null)
         return "Exception";
       return `Exception: ${this.message}`;
     }
   }
   _ExceptionImplementation[dart.implements] = () => [Exception];
   dart.setSignature(_ExceptionImplementation, {
     constructors: () => ({_ExceptionImplementation: [_ExceptionImplementation, [], [dart.dynamic]]})
   });
-  class FormatException extends Object {
+  class FormatException extends exports.Object {
     FormatException(message, source, offset) {
       if (message === void 0)
         message = "";
       if (source === void 0)
         source = null;
       if (offset === void 0)
         offset = -1;
       this.message = message;
       this.source = source;
       this.offset = offset;
@@ skipping 71 matching lines @@
       }
       let slice = dart.as(dart.dsend(this.source, 'substring', start, end), String);
       let markOffset = dart.notNull(offset) - dart.notNull(start) + dart.notNull(prefix[dartx.length]);
       return `${report}${prefix}${slice}${postfix}\n${" "[dartx['*']](markOffset)}^\n`;
     }
   }
   FormatException[dart.implements] = () => [Exception];
   dart.setSignature(FormatException, {
     constructors: () => ({FormatException: [FormatException, [], [String, dart.dynamic, int]]})
   });
-  class IntegerDivisionByZeroException extends Object {
+  class IntegerDivisionByZeroException extends exports.Object {
     IntegerDivisionByZeroException() {
     }
     toString() {
       return "IntegerDivisionByZeroException";
     }
   }
   IntegerDivisionByZeroException[dart.implements] = () => [Exception];
   dart.setSignature(IntegerDivisionByZeroException, {
     constructors: () => ({IntegerDivisionByZeroException: [IntegerDivisionByZeroException, []]})
   });
-  let _getKey = dart.JsSymbol('_getKey');
+  let _getKey = Symbol('_getKey');
   let Expando$ = dart.generic(function(T) {
-    class Expando extends Object {
+    class Expando extends exports.Object {
       Expando(name) {
         if (name === void 0)
           name = null;
         this.name = name;
       }
       toString() {
         return `Expando:${this.name}`;
       }
       get(object) {
         let values = _js_helper.Primitives.getProperty(object, Expando$()._EXPANDO_PROPERTY_NAME);
         return values == null ? null : dart.as(_js_helper.Primitives.getProperty(values, this[_getKey]()), T);
       }
       set(object, value) {
         dart.as(value, T);
         let values = _js_helper.Primitives.getProperty(object, Expando$()._EXPANDO_PROPERTY_NAME);
         if (values == null) {
-          values = new Object();
+          values = new exports.Object();
           _js_helper.Primitives.setProperty(object, Expando$()._EXPANDO_PROPERTY_NAME, values);
         }
         _js_helper.Primitives.setProperty(values, this[_getKey](), value);
         return value;
       }
       [_getKey]() {
         let key = dart.as(_js_helper.Primitives.getProperty(this, Expando$()._KEY_PROPERTY_NAME), String);
         if (key == null) {
           key = `expando$key$${(() => {
             let x = Expando$()._keyCount;
             Expando$()._keyCount = dart.notNull(x) + 1;
             return x;
           })()}`;
           _js_helper.Primitives.setProperty(this, Expando$()._KEY_PROPERTY_NAME, key);
         }
         return key;
       }
     }
     dart.setSignature(Expando, {
       constructors: () => ({Expando: [Expando$(T), [], [String]]}),
       methods: () => ({
-        get: [T, [Object]],
-        set: [dart.void, [Object, T]],
+        get: [T, [exports.Object]],
+        set: [dart.void, [exports.Object, T]],
         [_getKey]: [String, []]
       })
     });
     return Expando;
   });
   let Expando = Expando$();
   Expando._KEY_PROPERTY_NAME = 'expando$key';
   Expando._EXPANDO_PROPERTY_NAME = 'expando$values';
   Expando._keyCount = 0;
-  class Function extends Object {
+  class Function extends exports.Object {
     static apply(f, positionalArguments, namedArguments) {
       if (namedArguments === void 0)
         namedArguments = null;
       return dart.dcall.apply(null, [f].concat(positionalArguments));
     }
     static _toMangledNames(namedArguments) {
       let result = dart.map();
       namedArguments.forEach(dart.fn((symbol, value) => {
-        result.set(_symbolToString(dart.as(symbol, Symbol)), value);
+        result.set(_symbolToString(dart.as(symbol, exports.Symbol)), value);
       }));
       return result;
     }
   }
   dart.setSignature(Function, {
     statics: () => ({
-      apply: [dart.dynamic, [Function, List], [Map$(Symbol, dart.dynamic)]],
-      _toMangledNames: [Map$(String, dart.dynamic), [Map$(Symbol, dart.dynamic)]]
+      apply: [dart.dynamic, [Function, List], [Map$(exports.Symbol, dart.dynamic)]],
+      _toMangledNames: [Map$(String, dart.dynamic), [Map$(exports.Symbol, dart.dynamic)]]
     }),
     names: ['apply', '_toMangledNames']
   });
   function identical(a, b) {
     return _js_helper.Primitives.identicalImplementation(a, b);
   }
-  dart.fn(identical, bool, [Object, Object]);
+  dart.fn(identical, bool, [exports.Object, exports.Object]);
   function identityHashCode(object) {
     return _js_helper.objectHashCode(object);
   }
-  dart.fn(identityHashCode, () => dart.definiteFunctionType(int, [Object]));
+  dart.fn(identityHashCode, () => dart.definiteFunctionType(int, [exports.Object]));
   class int extends num {
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
       dart.throw(new UnsupportedError('int.fromEnvironment can only be used as a const constructor'));
     }
     static parse(source, opts) {
       let radix = opts && 'radix' in opts ? opts.radix : null;
       let onError = opts && 'onError' in opts ? opts.onError : null;
       return _js_helper.Primitives.parseInt(source, radix, onError);
     }
   }
   dart.setSignature(int, {
     constructors: () => ({fromEnvironment: [int, [String], {defaultValue: int}]}),
     statics: () => ({parse: [int, [String], {radix: int, onError: dart.functionType(int, [String])}]}),
     names: ['parse']
   });
-  class Invocation extends Object {
+  class Invocation extends exports.Object {
     get isAccessor() {
       return dart.notNull(this.isGetter) || dart.notNull(this.isSetter);
     }
   }
   let Iterable$ = dart.generic(function(E) {
     dart.defineExtensionNames([
       'join'
     ]);
-    class Iterable extends Object {
+    class Iterable extends exports.Object {
       Iterable() {
       }
       static generate(count, generator) {
         if (generator === void 0)
           generator = null;
         if (dart.notNull(count) <= 0)
           return new (_internal.EmptyIterable$(E))();
         return new (exports._GeneratorIterable$(E))(count, generator);
       }
-      [dart.JsSymbol.iterator]() {
+      [Symbol.iterator]() {
         return new dart.JsIterator(this[dartx.iterator]);
       }
       [dartx.join](separator) {
         if (separator === void 0)
           separator = "";
         let buffer = new StringBuffer();
         buffer.writeAll(this, separator);
         return dart.toString(buffer);
       }
     }
     dart.setSignature(Iterable, {
       constructors: () => ({
         Iterable: [Iterable$(E), []],
         generate: [Iterable$(E), [int], [dart.functionType(E, [int])]]
       }),
       methods: () => ({[dartx.join]: [String, [], [String]]})
     });
     return Iterable;
   });
   let Iterable = Iterable$();
   let _Generator$ = dart.generic(function(E) {
     let _Generator = dart.typedef('_Generator', () => dart.functionType(E, [int]));
     return _Generator;
   });
   let _Generator = _Generator$();
-  let _end = dart.JsSymbol('_end');
-  let _start = dart.JsSymbol('_start');
-  let _generator = dart.JsSymbol('_generator');
+  let _end = Symbol('_end');
+  let _start = Symbol('_start');
+  let _generator = Symbol('_generator');
   let _GeneratorIterable$ = dart.generic(function(E) {
     class _GeneratorIterable extends collection.IterableBase$(E) {
       _GeneratorIterable(end, generator) {
         this[_end] = end;
         this[_start] = 0;
         this[_generator] = dart.as(generator != null ? generator : exports._GeneratorIterable$()._id, _Generator$(E));
         super.IterableBase();
       }
       slice(start, end, generator) {
         this[_start] = start;
@@ skipping 40 matching lines @@
         skip: [Iterable$(E), [int]],
         take: [Iterable$(E), [int]]
       }),
       statics: () => ({_id: [int, [int]]}),
       names: ['_id']
     });
     dart.defineExtensionMembers(_GeneratorIterable, ['skip', 'take', 'iterator', 'length']);
     return _GeneratorIterable;
   });
   dart.defineLazyClassGeneric(exports, '_GeneratorIterable', {get: _GeneratorIterable$});
-  let _index = dart.JsSymbol('_index');
-  let _current = dart.JsSymbol('_current');
+  let _index = Symbol('_index');
+  let _current = Symbol('_current');
   let _GeneratorIterator$ = dart.generic(function(E) {
-    class _GeneratorIterator extends Object {
+    class _GeneratorIterator extends exports.Object {
       _GeneratorIterator(index, end, generator) {
         this[_index] = index;
         this[_end] = end;
         this[_generator] = generator;
         this[_current] = null;
       }
       moveNext() {
         if (dart.notNull(this[_index]) < dart.notNull(this[_end])) {
           this[_current] = this[_generator](this[_index]);
           this[_index] = dart.notNull(this[_index]) + 1;
           return true;
         } else {
           this[_current] = null;
           return false;
         }
       }
       get current() {
         return this[_current];
       }
     }
     _GeneratorIterator[dart.implements] = () => [Iterator$(E)];
     dart.setSignature(_GeneratorIterator, {
       constructors: () => ({_GeneratorIterator: [_GeneratorIterator$(E), [int, int, _Generator$(E)]]}),
       methods: () => ({moveNext: [bool, []]})
     });
     return _GeneratorIterator;
   });
   let _GeneratorIterator = _GeneratorIterator$();
   let BidirectionalIterator$ = dart.generic(function(E) {
-    class BidirectionalIterator extends Object {}
+    class BidirectionalIterator extends exports.Object {}
     BidirectionalIterator[dart.implements] = () => [Iterator$(E)];
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$();
   let Iterator$ = dart.generic(function(E) {
-    class Iterator extends Object {}
+    class Iterator extends exports.Object {}
     return Iterator;
   });
   let Iterator = Iterator$();
   let List$ = dart.generic(function(E) {
-    class List extends Object {
+    class List extends exports.Object {
       static new(length) {
         if (length === void 0)
           length = null;
         let list = null;
         if (length == null) {
           list = [];
         } else {
           if (!(typeof length == 'number') || dart.notNull(length) < 0) {
             dart.throw(new ArgumentError(`Length must be a non-negative integer: ${length}`));
           }
@@ skipping 27 matching lines @@
           result = dart.list([], E);
           result[dartx.length] = length;
         } else {
           result = List$(E).new(length);
         }
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result[dartx.set](i, generator(i));
         }
         return result;
       }
-      [dart.JsSymbol.iterator]() {
+      [Symbol.iterator]() {
         return new dart.JsIterator(this[dartx.iterator]);
       }
     }
     List[dart.implements] = () => [Iterable$(E)];
     dart.setSignature(List, {
       constructors: () => ({
         new: [List$(E), [], [int]],
         filled: [List$(E), [int, E]],
         from: [List$(E), [Iterable], {growable: bool}],
         generate: [List$(E), [int, dart.functionType(E, [int])], {growable: bool}]
       })
     });
     return List;
   });
   let List = List$();
   let Map$ = dart.generic(function(K, V) {
-    class Map extends Object {
+    class Map extends exports.Object {

[ochafik, 2015/09/15 16:58:33]

This one will be seen as a redefine in ES6 as well, I think.

       static new() {
         return collection.LinkedHashMap$(K, V).new();
       }
       static from(other) {
         return collection.LinkedHashMap$(K, V).from(other);
       }
       static identity() {
         return collection.LinkedHashMap$(K, V).identity();
       }
       static fromIterable(iterable, opts) {
         return collection.LinkedHashMap$(K, V).fromIterable(iterable, opts);
       }
       static fromIterables(keys, values) {
         return collection.LinkedHashMap$(K, V).fromIterables(keys, values);
       }
     }
     dart.setSignature(Map, {
       constructors: () => ({
         new: [Map$(K, V), []],
         from: [Map$(K, V), [Map$()]],
         identity: [Map$(K, V), []],
         fromIterable: [Map$(K, V), [Iterable], {key: dart.functionType(K, [dart.dynamic]), value: dart.functionType(V, [dart.dynamic])}],
         fromIterables: [Map$(K, V), [Iterable$(K), Iterable$(V)]]
       })
     });
     return Map;
   });
   let Map = Map$();
-  class Null extends Object {
+  class Null extends exports.Object {
     static _uninstantiable() {
       dart.throw(new UnsupportedError('class Null cannot be instantiated'));
     }
     toString() {
       return "null";
     }
   }
   dart.setSignature(Null, {
     constructors: () => ({_uninstantiable: [Null, []]})
   });
   num._parseError = false;
-  class Pattern extends Object {}
+  class Pattern extends exports.Object {}
   function print(object) {
     let line = `${object}`;
     if (_internal.printToZone == null) {
       _internal.printToConsole(line);
     } else {
       dart.dcall(_internal.printToZone, line);
     }
   }
-  dart.fn(print, dart.void, [Object]);
-  class Match extends Object {}
-  class RegExp extends Object {
+  dart.fn(print, dart.void, [exports.Object]);
+  class Match extends exports.Object {}
+  class RegExp extends exports.Object {
     static new(source, opts) {
       let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
       let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
       return new _js_helper.JSSyntaxRegExp(source, {multiLine: multiLine, caseSensitive: caseSensitive});
     }
   }
   RegExp[dart.implements] = () => [Pattern];
   dart.setSignature(RegExp, {
     constructors: () => ({new: [RegExp, [String], {multiLine: bool, caseSensitive: bool}]})
   });
@@ skipping 14 matching lines @@
       constructors: () => ({
         new: [exports.Set$(E), []],
         identity: [exports.Set$(E), []],
         from: [exports.Set$(E), [Iterable]]
       })
     });
     return Set;
   });
   dart.defineLazyClassGeneric(exports, 'Set', {get: Set$});
   let Sink$ = dart.generic(function(T) {
-    class Sink extends Object {}
+    class Sink extends exports.Object {}
     return Sink;
   });
   let Sink = Sink$();
-  class StackTrace extends Object {}
-  let _stop = dart.JsSymbol('_stop');
-  class Stopwatch extends Object {
+  class StackTrace extends exports.Object {}
+  let _stop = Symbol('_stop');
+  class Stopwatch extends exports.Object {
     get frequency() {
       return Stopwatch._frequency;
     }
     Stopwatch() {
       this[_start] = null;
       this[_stop] = null;
       Stopwatch._initTicker();
     }
     start() {
       if (dart.notNull(this.isRunning))
@@ skipping 51 matching lines @@
       stop: [dart.void, []],
       reset: [dart.void, []]
     }),
     statics: () => ({
       _initTicker: [dart.void, []],
       _now: [int, []]
     }),
     names: ['_initTicker', '_now']
   });
   Stopwatch._frequency = null;
-  class String extends Object {
+  class String extends exports.Object {
     static fromCharCodes(charCodes, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (!dart.is(charCodes, _interceptors.JSArray)) {
         return String._stringFromIterable(charCodes, start, end);
       }
       let list = dart.as(charCodes, List);
       let len = list[dartx.length];
@@ skipping 91 matching lines @@
   }
   dart.fn(_isLeadSurrogate, bool, [int]);
   function _isTrailSurrogate(code) {
     return (dart.notNull(code) & 64512) == 56320;
   }
   dart.fn(_isTrailSurrogate, bool, [int]);
   function _combineSurrogatePair(start, end) {
     return 65536 + ((dart.notNull(start) & 1023) << 10) + (dart.notNull(end) & 1023);
   }
   dart.fn(_combineSurrogatePair, int, [int, int]);
-  let _position = dart.JsSymbol('_position');
-  let _nextPosition = dart.JsSymbol('_nextPosition');
-  let _currentCodePoint = dart.JsSymbol('_currentCodePoint');
-  let _checkSplitSurrogate = dart.JsSymbol('_checkSplitSurrogate');
-  class RuneIterator extends Object {
+  let _position = Symbol('_position');
+  let _nextPosition = Symbol('_nextPosition');
+  let _currentCodePoint = Symbol('_currentCodePoint');
+  let _checkSplitSurrogate = Symbol('_checkSplitSurrogate');
+  class RuneIterator extends exports.Object {
     RuneIterator(string) {
       this.string = string;
       this[_position] = 0;
       this[_nextPosition] = 0;
       this[_currentCodePoint] = null;
     }
     at(string, index) {
       this.string = string;
       this[_position] = index;
       this[_nextPosition] = index;
@@ skipping 83 matching lines @@
       RuneIterator: [RuneIterator, [String]],
       at: [RuneIterator, [String, int]]
     }),
     methods: () => ({
       [_checkSplitSurrogate]: [dart.void, [int]],
       reset: [dart.void, [], [int]],
       moveNext: [bool, []],
       movePrevious: [bool, []]
     })
   });
-  let _contents = dart.JsSymbol('_contents');
-  let _writeString = dart.JsSymbol('_writeString');
-  class StringBuffer extends Object {
+  let _contents = Symbol('_contents');
+  let _writeString = Symbol('_writeString');
+  class StringBuffer extends exports.Object {
     StringBuffer(content) {
       if (content === void 0)
         content = "";
       this[_contents] = `${content}`;
     }
     get length() {
       return this[_contents][dartx.length];
     }
     get isEmpty() {
       return this.length == 0;
@@ skipping 36 matching lines @@
     }
     toString() {
       return _js_helper.Primitives.flattenString(this[_contents]);
     }
     [_writeString](str) {
       this[_contents] = _js_helper.Primitives.stringConcatUnchecked(this[_contents], dart.as(str, String));
     }
   }
   StringBuffer[dart.implements] = () => [StringSink];
   dart.setSignature(StringBuffer, {
-    constructors: () => ({StringBuffer: [StringBuffer, [], [Object]]}),
+    constructors: () => ({StringBuffer: [StringBuffer, [], [exports.Object]]}),
     methods: () => ({
-      write: [dart.void, [Object]],
+      write: [dart.void, [exports.Object]],
       writeCharCode: [dart.void, [int]],
       writeAll: [dart.void, [Iterable], [String]],
-      writeln: [dart.void, [], [Object]],
+      writeln: [dart.void, [], [exports.Object]],
       clear: [dart.void, []],
       [_writeString]: [dart.void, [dart.dynamic]]
     })
   });
-  class StringSink extends Object {}
-  class Symbol extends Object {
-    static new(name) {
-      return new _internal.Symbol(name);
+  class StringSink extends exports.Object {}
+  exports.Symbol = (() => {
+    class Symbol extends exports.Object {
+      static new(name) {
+        return new _internal.Symbol(name);
+      }
     }
-  }
-  dart.setSignature(Symbol, {
-    constructors: () => ({new: [Symbol, [String]]})
-  });
-  class Type extends Object {}
-  let _writeAuthority = dart.JsSymbol('_writeAuthority');
-  let _userInfo = dart.JsSymbol('_userInfo');
-  let _host = dart.JsSymbol('_host');
-  let _port = dart.JsSymbol('_port');
-  let _path = dart.JsSymbol('_path');
-  let _query = dart.JsSymbol('_query');
-  let _fragment = dart.JsSymbol('_fragment');
-  let _pathSegments = dart.JsSymbol('_pathSegments');
-  let _queryParameters = dart.JsSymbol('_queryParameters');
-  let _merge = dart.JsSymbol('_merge');
-  let _hasDotSegments = dart.JsSymbol('_hasDotSegments');
-  let _removeDotSegments = dart.JsSymbol('_removeDotSegments');
-  let _toWindowsFilePath = dart.JsSymbol('_toWindowsFilePath');
-  let _toFilePath = dart.JsSymbol('_toFilePath');
-  let _isPathAbsolute = dart.JsSymbol('_isPathAbsolute');
-  class Uri extends Object {
+    dart.setSignature(Symbol, {
+      constructors: () => ({new: [exports.Symbol, [String]]})
+    });
+    return Symbol;
+  })();
+  class Type extends exports.Object {}
+  let _writeAuthority = Symbol('_writeAuthority');
+  let _userInfo = Symbol('_userInfo');
+  let _host = Symbol('_host');
+  let _port = Symbol('_port');
+  let _path = Symbol('_path');
+  let _query = Symbol('_query');
+  let _fragment = Symbol('_fragment');
+  let _pathSegments = Symbol('_pathSegments');
+  let _queryParameters = Symbol('_queryParameters');
+  let _merge = Symbol('_merge');
+  let _hasDotSegments = Symbol('_hasDotSegments');
+  let _removeDotSegments = Symbol('_removeDotSegments');
+  let _toWindowsFilePath = Symbol('_toWindowsFilePath');
+  let _toFilePath = Symbol('_toFilePath');
+  let _isPathAbsolute = Symbol('_isPathAbsolute');
+  class Uri extends exports.Object {
     get authority() {
       if (!dart.notNull(this.hasAuthority))
         return "";
       let sb = new StringBuffer();
       this[_writeAuthority](sb);
       return dart.toString(sb);
     }
     get userInfo() {
       return this[_userInfo];
     }
@@ skipping 1331 matching lines @@
   Uri._subDelimitersTable = dart.const([0, 0, 32722, 11263, 65534, 34815, 65534, 18431]);
   Uri._genDelimitersTable = dart.const([0, 0, 32776, 33792, 1, 10240, 0, 0]);
   Uri._userinfoTable = dart.const([0, 0, 32722, 12287, 65534, 34815, 65534, 18431]);
   Uri._regNameTable = dart.const([0, 0, 32754, 11263, 65534, 34815, 65534, 18431]);
   Uri._pathCharTable = dart.const([0, 0, 32722, 12287, 65535, 34815, 65534, 18431]);
   Uri._pathCharOrSlashTable = dart.const([0, 0, 65490, 12287, 65535, 34815, 65534, 18431]);
   Uri._queryCharTable = dart.const([0, 0, 65490, 45055, 65535, 34815, 65534, 18431]);
   function _symbolToString(symbol) {
     return _internal.Symbol.getName(dart.as(symbol, _internal.Symbol));
   }
-  dart.fn(_symbolToString, String, [Symbol]);
+  dart.fn(_symbolToString, String, [exports.Symbol]);
   // Exports:
-  exports.Object = Object;
   exports.Deprecated = Deprecated;
   exports.deprecated = deprecated;
   exports.override = override;
   exports.proxy = proxy;
   exports.bool = bool;
   exports.Comparator$ = Comparator$;
   exports.Comparator = Comparator;
   exports.Comparable$ = Comparable$;
   exports.Comparable = Comparable;
   exports.DateTime = DateTime;
   exports.num = num;
   exports.double = double;
   exports.Duration = Duration;
-  exports.Error = Error;
   exports.AssertionError = AssertionError;
   exports.TypeError = TypeError;
   exports.CastError = CastError;
   exports.NullThrownError = NullThrownError;
   exports.ArgumentError = ArgumentError;
   exports.RangeError = RangeError;
   exports.IndexError = IndexError;
   exports.FallThroughError = FallThroughError;
   exports.AbstractClassInstantiationError = AbstractClassInstantiationError;
   exports.NoSuchMethodError = NoSuchMethodError;
@@ skipping 31 matching lines @@
   exports.RegExp = RegExp;
   exports.Set$ = Set$;
   exports.Sink$ = Sink$;
   exports.Sink = Sink;
   exports.StackTrace = StackTrace;
   exports.Stopwatch = Stopwatch;
   exports.String = String;
   exports.RuneIterator = RuneIterator;
   exports.StringBuffer = StringBuffer;
   exports.StringSink = StringSink;
-  exports.Symbol = Symbol;
   exports.Type = Type;
   exports.Uri = Uri;
 });