Fixes #254 - Better stacktrace support

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;
     }
     ['=='](other) {
       return identical(this, other);
     }
     get hashCode() {
       return _js_helper.Primitives.objectHashCode(this);
     }
     toString() {
       return _js_helper.Primitives.objectToString(this);
     }
     noSuchMethod(invocation) {
-      throw new NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments);
+      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, []],
@@ skipping 27 matching lines @@
   dart.setSignature(_Proxy, {
     constructors: () => ({_Proxy: [_Proxy, []]})
   });
   let proxy = dart.const(new _Proxy());
   dart.defineExtensionNames([
     'toString'
   ]);
   class bool extends Object {
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : false;
-      throw new UnsupportedError('bool.fromEnvironment can only be used as a const constructor');
+      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]));
@@ skipping 81 matching lines @@
           if (match.get(9) != null) {
             let sign = match.get(9) == '-' ? -1 : 1;
             let hourDifference = int.parse(match.get(10));
             let minuteDifference = parseIntOrZero(match.get(11));
             minuteDifference = dart.notNull(minuteDifference) + 60 * dart.notNull(hourDifference);
             minute = dart.notNull(minute) - dart.notNull(sign) * dart.notNull(minuteDifference);
           }
         }
         let millisecondsSinceEpoch = DateTime._brokenDownDateToMillisecondsSinceEpoch(years, month, day, hour, minute, second, millisecond, isUtc);
         if (millisecondsSinceEpoch == null) {
-          throw new FormatException("Time out of range", formattedString);
+          dart.throw(new FormatException("Time out of range", formattedString));
         }
         if (dart.notNull(addOneMillisecond)) {
           millisecondsSinceEpoch = dart.notNull(millisecondsSinceEpoch) + 1;
         }
         return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, {isUtc: isUtc});
       } else {
-        throw new FormatException("Invalid date format", formattedString);
+        dart.throw(new FormatException("Invalid date format", formattedString));
       }
     }
     fromMillisecondsSinceEpoch(millisecondsSinceEpoch, opts) {
       let isUtc = opts && 'isUtc' in opts ? opts.isUtc : false;
       this.millisecondsSinceEpoch = millisecondsSinceEpoch;
       this.isUtc = isUtc;
       if (dart.notNull(millisecondsSinceEpoch[dartx.abs]()) > dart.notNull(DateTime._MAX_MILLISECONDS_SINCE_EPOCH)) {
-        throw new ArgumentError(millisecondsSinceEpoch);
+        dart.throw(new ArgumentError(millisecondsSinceEpoch));
       }
       if (isUtc == null)
-        throw new ArgumentError(isUtc);
+        dart.throw(new ArgumentError(isUtc));
     }
     ['=='](other) {
       if (!dart.is(other, DateTime))
         return false;
       return dart.equals(this.millisecondsSinceEpoch, dart.dload(other, 'millisecondsSinceEpoch')) && dart.equals(this.isUtc, dart.dload(other, 'isUtc'));
     }
     isBefore(other) {
       return dart.notNull(this.millisecondsSinceEpoch) < dart.notNull(other.millisecondsSinceEpoch);
     }
     isAfter(other) {
@@ skipping 85 matching lines @@
     subtract(duration) {
       let ms = this.millisecondsSinceEpoch;
       return new DateTime.fromMillisecondsSinceEpoch(dart.notNull(ms) - dart.notNull(duration.inMilliseconds), {isUtc: this.isUtc});
     }
     difference(other) {
       let ms = this.millisecondsSinceEpoch;
       let otherMs = other.millisecondsSinceEpoch;
       return new Duration({milliseconds: dart.notNull(ms) - dart.notNull(otherMs)});
     }
     _internal(year, month, day, hour, minute, second, millisecond, isUtc) {
-      this.isUtc = typeof isUtc == 'boolean' ? isUtc : dart.throw_(new ArgumentError(isUtc));
+      this.isUtc = typeof isUtc == 'boolean' ? isUtc : dart.throw(new ArgumentError(isUtc));
       this.millisecondsSinceEpoch = dart.as(_js_helper.checkInt(_js_helper.Primitives.valueFromDecomposedDate(year, month, day, hour, minute, second, millisecond, isUtc)), int);
     }
     _now() {
       this.isUtc = false;
       this.millisecondsSinceEpoch = _js_helper.Primitives.dateNow();
     }
     static _brokenDownDateToMillisecondsSinceEpoch(year, month, day, hour, minute, second, millisecond, isUtc) {
       return dart.as(_js_helper.Primitives.valueFromDecomposedDate(year, month, day, hour, minute, second, millisecond, isUtc), int);
     }
     get timeZoneName() {
@@ skipping 98 matching lines @@
       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);
       if (!dart.notNull(num._parseError))
         return result;
       if (onError == null)
-        throw new FormatException(input);
+        dart.throw(new FormatException(input));
       return onError(input);
     }
     static _onParseErrorInt(_) {
       num._parseError = true;
       return 0;
     }
     static _onParseErrorDouble(_) {
       num._parseError = true;
       return 0.0;
     }
@@ skipping 41 matching lines @@
       return new Duration._microseconds(dart.notNull(this[_duration]) + dart.notNull(other[_duration]));
     }
     ['-'](other) {
       return new Duration._microseconds(dart.notNull(this[_duration]) - dart.notNull(other[_duration]));
     }
     ['*'](factor) {
       return new Duration._microseconds((dart.notNull(this[_duration]) * dart.notNull(factor))[dartx.round]());
     }
     ['~/'](quotient) {
       if (quotient == 0)
-        throw new IntegerDivisionByZeroException();
+        dart.throw(new IntegerDivisionByZeroException());
       return new Duration._microseconds((dart.notNull(this[_duration]) / dart.notNull(quotient)).truncate());
     }
     ['<'](other) {
       return dart.notNull(this[_duration]) < dart.notNull(other[_duration]);
     }
     ['>'](other) {
       return dart.notNull(this[_duration]) > dart.notNull(other[_duration]);
     }
     ['<='](other) {
       return dart.notNull(this[_duration]) <= dart.notNull(other[_duration]);
@@ skipping 234 matching lines @@
     }
     static index(index, indexable, name, message, length) {
       return new IndexError(index, indexable, name, message, length);
     }
     static checkValueInInterval(value, minValue, maxValue, name, message) {
       if (name === void 0)
         name = null;
       if (message === void 0)
         message = null;
       if (dart.notNull(value) < dart.notNull(minValue) || dart.notNull(value) > dart.notNull(maxValue)) {
-        throw new RangeError.range(value, minValue, maxValue, name, message);
+        dart.throw(new RangeError.range(value, minValue, maxValue, name, message));
       }
     }
     static checkValidIndex(index, indexable, name, length, message) {
       if (name === void 0)
         name = null;
       if (length === void 0)
         length = null;
       if (message === void 0)
         message = null;
       if (length == null)
         length = dart.as(dart.dload(indexable, 'length'), int);
       if (dart.notNull(index) < 0 || dart.notNull(index) >= dart.notNull(length)) {
         if (name == null)
           name = "index";
-        throw RangeError.index(index, indexable, name, message, length);
+        dart.throw(RangeError.index(index, indexable, name, message, length));
       }
     }
     static checkValidRange(start, end, length, startName, endName, message) {
       if (startName === void 0)
         startName = null;
       if (endName === void 0)
         endName = null;
       if (message === void 0)
         message = null;
       if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(length)) {
         if (startName == null)
           startName = "start";
-        throw new RangeError.range(start, 0, length, startName, message);
+        dart.throw(new RangeError.range(start, 0, length, startName, message));
       }
       if (end != null && (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(length))) {
         if (endName == null)
           endName = "end";
-        throw new RangeError.range(end, start, length, endName, message);
+        dart.throw(new RangeError.range(end, start, length, endName, message));
       }
     }
     static checkNotNegative(value, name, message) {
       if (name === void 0)
         name = null;
       if (message === void 0)
         message = null;
       if (dart.notNull(value) < 0)
-        throw new RangeError.range(value, 0, null, name, message);
+        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 explanation = "";
       if (this.start == null) {
         if (this.end != null) {
           explanation = `: Not less than or equal to ${this.end}`;
         }
@@ skipping 439 matching lines @@
     return _js_helper.Primitives.identicalImplementation(a, b);
   }
   dart.fn(identical, bool, [Object, Object]);
   function identityHashCode(object) {
     return _js_helper.objectHashCode(object);
   }
   dart.fn(identityHashCode, () => dart.definiteFunctionType(int, [Object]));
   class int extends num {
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
-      throw new UnsupportedError('int.fromEnvironment can only be used as a const constructor');
+      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])}]}),
@@ skipping 153 matching lines @@
   let List$ = dart.generic(function(E) {
     class List extends 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) {
-            throw new ArgumentError(`Length must be a non-negative integer: ${length}`);
+            dart.throw(new ArgumentError(`Length must be a non-negative integer: ${length}`));
           }
           list = _interceptors.JSArray.markFixedList(dart.as(new Array(length), List$()));
         }
         return _interceptors.JSArray$(E).typed(list);
       }
       static filled(length, fill) {
         let result = List$(E).new(length);
         if (length != 0 && fill != null) {
           for (let i = 0; dart.notNull(i) < dart.notNull(result[dartx.length]); i = dart.notNull(i) + 1) {
             result[dartx.set](i, fill);
@@ skipping 66 matching lines @@
         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 {
     static _uninstantiable() {
-      throw new UnsupportedError('class Null cannot be instantiated');
+      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 {}
@@ skipping 125 matching lines @@
       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];
       if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(len)) {
-        throw new RangeError.range(start, 0, len);
+        dart.throw(new RangeError.range(start, 0, len));
       }
       if (end == null) {
         end = len;
       } else if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(len)) {
-        throw new RangeError.range(end, start, len);
+        dart.throw(new RangeError.range(end, start, len));
       }
       if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(len)) {
         list = list[dartx.sublist](start, end);
       }
       return _js_helper.Primitives.stringFromCharCodes(list);
     }
     static fromCharCode(charCode) {
       return _js_helper.Primitives.stringFromCharCode(charCode);
     }
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
-      throw new UnsupportedError('String.fromEnvironment can only be used as a const constructor');
+      dart.throw(new UnsupportedError('String.fromEnvironment can only be used as a const constructor'));
     }
     static _stringFromIterable(charCodes, start, end) {
       if (dart.notNull(start) < 0)
-        throw new RangeError.range(start, 0, charCodes[dartx.length]);
+        dart.throw(new RangeError.range(start, 0, charCodes[dartx.length]));
       if (end != null && dart.notNull(end) < dart.notNull(start)) {
-        throw new RangeError.range(end, start, charCodes[dartx.length]);
+        dart.throw(new RangeError.range(end, start, charCodes[dartx.length]));
       }
       let it = charCodes[dartx.iterator];
       for (let i = 0; dart.notNull(i) < dart.notNull(start); i = dart.notNull(i) + 1) {
         if (!dart.notNull(it.moveNext())) {
-          throw new RangeError.range(start, 0, i);
+          dart.throw(new RangeError.range(start, 0, i));
         }
       }
       let list = [];
       if (end == null) {
         while (dart.notNull(it.moveNext()))
           list[dartx.add](it.current);
       } else {
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           if (!dart.notNull(it.moveNext())) {
-            throw new RangeError.range(end, start, i);
+            dart.throw(new RangeError.range(end, start, i));
           }
           list[dartx.add](it.current);
         }
       }
       return _js_helper.Primitives.stringFromCharCodes(list);
     }
   }
   String[dart.implements] = () => [Comparable$(String), Pattern];
   dart.setSignature(String, {
     constructors: () => ({
       fromCharCodes: [String, [Iterable$(int)], [int, int]],
       fromCharCode: [String, [int]],
       fromEnvironment: [String, [String], {defaultValue: String}]
     }),
     statics: () => ({_stringFromIterable: [String, [Iterable$(int), int, int]]}),
     names: ['_stringFromIterable']
   });
   dart.defineLazyClass(exports, {
     get Runes() {
       class Runes extends collection.IterableBase$(int) {
         Runes(string) {
           this.string = string;
           super.IterableBase();
         }
         get iterator() {
           return new RuneIterator(this.string);
         }
         get last() {
           if (this.string[dartx.length] == 0) {
-            throw new StateError('No elements.');
+            dart.throw(new StateError('No elements.'));
           }
           let length = this.string[dartx.length];
           let code = this.string[dartx.codeUnitAt](dart.notNull(length) - 1);
           if (dart.notNull(_isTrailSurrogate(code)) && dart.notNull(this.string[dartx.length]) > 1) {
             let previousCode = this.string[dartx.codeUnitAt](dart.notNull(length) - 2);
             if (dart.notNull(_isLeadSurrogate(previousCode))) {
               return _combineSurrogatePair(previousCode, code);
             }
           }
           return code;
@@ skipping 32 matching lines @@
     at(string, index) {
       this.string = string;
       this[_position] = index;
       this[_nextPosition] = index;
       this[_currentCodePoint] = null;
       RangeError.checkValueInInterval(index, 0, string[dartx.length]);
       this[_checkSplitSurrogate](index);
     }
     [_checkSplitSurrogate](index) {
       if (dart.notNull(index) > 0 && dart.notNull(index) < dart.notNull(this.string[dartx.length]) && dart.notNull(_isLeadSurrogate(this.string[dartx.codeUnitAt](dart.notNull(index) - 1))) && dart.notNull(_isTrailSurrogate(this.string[dartx.codeUnitAt](index)))) {
-        throw new ArgumentError(`Index inside surrogate pair: ${index}`);
+        dart.throw(new ArgumentError(`Index inside surrogate pair: ${index}`));
       }
     }
     get rawIndex() {
       return this[_position] != this[_nextPosition] ? this[_position] : null;
     }
     set rawIndex(rawIndex) {
       RangeError.checkValidIndex(rawIndex, this.string, "rawIndex");
       this.reset(rawIndex);
       this.moveNext();
     }
@@ skipping 365 matching lines @@
         } else {
           query = Uri._makeQuery(uri, dart.notNull(index) + 1, numberSignIndex, null);
           fragment = Uri._makeFragment(uri, dart.notNull(numberSignIndex) + 1, uri[dartx.length]);
         }
       } else if (char == Uri._NUMBER_SIGN) {
         fragment = Uri._makeFragment(uri, dart.notNull(index) + 1, uri[dartx.length]);
       }
       return new Uri._internal(scheme, userinfo, host, port, path, query, fragment);
     }
     static _fail(uri, index, message) {
-      throw new FormatException(message, uri, index);
+      dart.throw(new FormatException(message, uri, index));
     }
     _internal(scheme, userInfo, host, port, path, query, fragment) {
       this.scheme = scheme;
       this[_userInfo] = userInfo;
       this[_host] = host;
       this[_port] = port;
       this[_path] = path;
       this[_query] = query;
       this[_fragment] = fragment;
       this[_pathSegments] = null;
@@ skipping 50 matching lines @@
             break;
           }
         }
         let hostEnd = hostStart;
         if (dart.notNull(hostStart) < dart.notNull(authority[dartx.length]) && authority[dartx.codeUnitAt](hostStart) == Uri._LEFT_BRACKET) {
           for (; dart.notNull(hostEnd) < dart.notNull(authority[dartx.length]); hostEnd = dart.notNull(hostEnd) + 1) {
             if (authority[dartx.codeUnitAt](hostEnd) == Uri._RIGHT_BRACKET)
               break;
           }
           if (hostEnd == authority[dartx.length]) {
-            throw new FormatException("Invalid IPv6 host entry.", authority, hostStart);
+            dart.throw(new FormatException("Invalid IPv6 host entry.", authority, hostStart));
           }
           Uri.parseIPv6Address(authority, dart.notNull(hostStart) + 1, hostEnd);
           hostEnd = dart.notNull(hostEnd) + 1;
           if (hostEnd != authority[dartx.length] && authority[dartx.codeUnitAt](hostEnd) != Uri._COLON) {
-            throw new FormatException("Invalid end of authority", authority, hostEnd);
+            dart.throw(new FormatException("Invalid end of authority", authority, hostEnd));
           }
         }
         let hasPort = false;
         for (; dart.notNull(hostEnd) < dart.notNull(authority[dartx.length]); hostEnd = dart.notNull(hostEnd) + 1) {
           if (authority[dartx.codeUnitAt](hostEnd) == Uri._COLON) {
             let portString = authority[dartx.substring](dart.notNull(hostEnd) + 1);
             if (dart.notNull(portString[dartx.isNotEmpty]))
               port = int.parse(portString);
             break;
           }
         }
         host = authority[dartx.substring](hostStart, hostEnd);
       }
       return Uri.new({scheme: scheme, userInfo: userInfo, host: dart.as(host, String), port: dart.as(port, int), pathSegments: unencodedPath[dartx.split]("/"), queryParameters: queryParameters});
     }
     static file(path, opts) {
       let windows = opts && 'windows' in opts ? opts.windows : null;
       windows = windows == null ? Uri._isWindows : windows;
       return dart.notNull(windows) ? dart.as(Uri._makeWindowsFileUrl(path), Uri) : dart.as(Uri._makeFileUri(path), Uri);
     }
     static get base() {
       let uri = _js_helper.Primitives.currentUri();
       if (uri != null)
         return Uri.parse(uri);
-      throw new UnsupportedError("'Uri.base' is not supported");
+      dart.throw(new UnsupportedError("'Uri.base' is not supported"));
     }
     static get _isWindows() {
       return false;
     }
     static _checkNonWindowsPathReservedCharacters(segments, argumentError) {
       segments[dartx.forEach](dart.fn(segment => {
         if (dart.notNull(dart.as(dart.dsend(segment, 'contains', "/"), bool))) {
           if (dart.notNull(argumentError)) {
-            throw new ArgumentError(`Illegal path character ${segment}`);
+            dart.throw(new ArgumentError(`Illegal path character ${segment}`));
           } else {
-            throw new UnsupportedError(`Illegal path character ${segment}`);
+            dart.throw(new UnsupportedError(`Illegal path character ${segment}`));
           }
         }
       }));
     }
     static _checkWindowsPathReservedCharacters(segments, argumentError, firstSegment) {
       if (firstSegment === void 0)
         firstSegment = 0;
       segments[dartx.skip](firstSegment)[dartx.forEach](dart.fn(segment => {
         if (dart.notNull(dart.as(dart.dsend(segment, 'contains', RegExp.new('["*/:<>?\\\\|]')), bool))) {
           if (dart.notNull(argumentError)) {
-            throw new ArgumentError("Illegal character in path");
+            dart.throw(new ArgumentError("Illegal character in path"));
           } else {
-            throw new UnsupportedError("Illegal character in path");
+            dart.throw(new UnsupportedError("Illegal character in path"));
           }
         }
       }));
     }
     static _checkWindowsDriveLetter(charCode, argumentError) {
       if (dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._UPPER_CASE_Z) || dart.notNull(Uri._LOWER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._LOWER_CASE_Z)) {
         return;
       }
       if (dart.notNull(argumentError)) {
-        throw new ArgumentError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode)));
+        dart.throw(new ArgumentError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode))));
       } else {
-        throw new UnsupportedError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode)));
+        dart.throw(new UnsupportedError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode))));
       }
     }
     static _makeFileUri(path) {
       let sep = "/";
       if (dart.notNull(path[dartx.startsWith](sep))) {
         return Uri.new({scheme: "file", pathSegments: path[dartx.split](sep)});
       } else {
         return Uri.new({pathSegments: path[dartx.split](sep)});
       }
     }
     static _makeWindowsFileUrl(path) {
       if (dart.notNull(path[dartx.startsWith]("\\\\?\\"))) {
         if (dart.notNull(path[dartx.startsWith]("\\\\?\\UNC\\"))) {
           path = `\\${path[dartx.substring](7)}`;
         } else {
           path = path[dartx.substring](4);
           if (dart.notNull(path[dartx.length]) < 3 || path[dartx.codeUnitAt](1) != Uri._COLON || path[dartx.codeUnitAt](2) != Uri._BACKSLASH) {
-            throw new ArgumentError("Windows paths with \\\\?\\ prefix must be absolute");
+            dart.throw(new ArgumentError("Windows paths with \\\\?\\ prefix must be absolute"));
           }
         }
       } else {
         path = path[dartx.replaceAll]("/", "\\");
       }
       let sep = "\\";
       if (dart.notNull(path[dartx.length]) > 1 && path[dartx.get](1) == ":") {
         Uri._checkWindowsDriveLetter(path[dartx.codeUnitAt](0), true);
         if (path[dartx.length] == 2 || path[dartx.codeUnitAt](2) != Uri._BACKSLASH) {
-          throw new ArgumentError("Windows paths with drive letter must be absolute");
+          dart.throw(new ArgumentError("Windows paths with drive letter must be absolute"));
         }
         let pathSegments = path[dartx.split](sep);
         Uri._checkWindowsPathReservedCharacters(pathSegments, true, 1);
         return Uri.new({scheme: "file", pathSegments: pathSegments});
       }
       if (dart.notNull(path[dartx.length]) > 0 && path[dartx.get](0) == sep) {
         if (dart.notNull(path[dartx.length]) > 1 && path[dartx.get](1) == sep) {
           let pathStart = path[dartx.indexOf]("\\", 2);
           let hostPart = pathStart == -1 ? path[dartx.substring](2) : path[dartx.substring](2, pathStart);
           let pathPart = pathStart == -1 ? "" : path[dartx.substring](dart.notNull(pathStart) + 1);
@@ skipping 210 matching lines @@
     }
     static _makeUserInfo(userInfo, start, end) {
       if (userInfo == null)
         return "";
       return Uri._normalize(userInfo, start, end, dart.as(Uri._userinfoTable, List$(int)));
     }
     static _makePath(path, start, end, pathSegments, ensureLeadingSlash, isFile) {
       if (path == null && pathSegments == null)
         return dart.notNull(isFile) ? "/" : "";
       if (path != null && pathSegments != null) {
-        throw new ArgumentError('Both path and pathSegments specified');
+        dart.throw(new ArgumentError('Both path and pathSegments specified'));
       }
       let result = null;
       if (path != null) {
         result = Uri._normalize(path, start, end, dart.as(Uri._pathCharOrSlashTable, List$(int)));
       } else {
         result = pathSegments[dartx.map](dart.fn(s => Uri._uriEncode(dart.as(Uri._pathCharTable, List$(int)), dart.as(s, String)), String, [dart.dynamic]))[dartx.join]("/");
       }
       if (dart.notNull(dart.as(dart.dload(result, 'isEmpty'), bool))) {
         if (dart.notNull(isFile))
           return "/";
       } else if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash)) && !dart.equals(dart.dsend(result, 'codeUnitAt', 0), Uri._SLASH)) {
         return `/${result}`;
       }
       return dart.as(result, String);
     }
     static _makeQuery(query, start, end, queryParameters) {
       if (query == null && queryParameters == null)
         return null;
       if (query != null && queryParameters != null) {
-        throw new ArgumentError('Both query and queryParameters specified');
+        dart.throw(new ArgumentError('Both query and queryParameters specified'));
       }
       if (query != null)
         return Uri._normalize(query, start, end, dart.as(Uri._queryCharTable, List$(int)));
       let result = new StringBuffer();
       let first = true;
       queryParameters.forEach(dart.fn((key, value) => {
         if (!dart.notNull(first)) {
           result.write("&");
         }
         first = false;
@@ skipping 260 matching lines @@
       return this[_port] != null;
     }
     get hasQuery() {
       return this[_query] != null;
     }
     get hasFragment() {
       return this[_fragment] != null;
     }
     get origin() {
       if (this.scheme == "" || this[_host] == null || this[_host] == "") {
-        throw new StateError(`Cannot use origin without a scheme: ${this}`);
+        dart.throw(new StateError(`Cannot use origin without a scheme: ${this}`));
       }
       if (this.scheme != "http" && this.scheme != "https") {
-        throw new StateError(`Origin is only applicable schemes http and https: ${this}`);
+        dart.throw(new StateError(`Origin is only applicable schemes http and https: ${this}`));
       }
       if (this[_port] == null)
         return `${this.scheme}://${this[_host]}`;
       return `${this.scheme}://${this[_host]}:${this[_port]}`;
     }
     toFilePath(opts) {
       let windows = opts && 'windows' in opts ? opts.windows : null;
       if (this.scheme != "" && this.scheme != "file") {
-        throw new UnsupportedError(`Cannot extract a file path from a ${this.scheme} URI`);
+        dart.throw(new UnsupportedError(`Cannot extract a file path from a ${this.scheme} URI`));
       }
       if (this.query != "") {
-        throw new UnsupportedError("Cannot extract a file path from a URI with a query component");
+        dart.throw(new UnsupportedError("Cannot extract a file path from a URI with a query component"));
       }
       if (this.fragment != "") {
-        throw new UnsupportedError("Cannot extract a file path from a URI with a fragment component");
+        dart.throw(new UnsupportedError("Cannot extract a file path from a URI with a fragment component"));
       }
       if (windows == null)
         windows = Uri._isWindows;
       return dart.notNull(windows) ? this[_toWindowsFilePath]() : this[_toFilePath]();
     }
     [_toFilePath]() {
       if (this.host != "") {
-        throw new UnsupportedError("Cannot extract a non-Windows file path from a file URI " + "with an authority");
+        dart.throw(new UnsupportedError("Cannot extract a non-Windows file path from a file URI " + "with an authority"));
       }
       Uri._checkNonWindowsPathReservedCharacters(this.pathSegments, false);
       let result = new StringBuffer();
       if (dart.notNull(this[_isPathAbsolute]))
         result.write("/");
       result.writeAll(this.pathSegments, "/");
       return dart.toString(result);
     }
     [_toWindowsFilePath]() {
       let hasDriveLetter = false;
@@ skipping 103 matching lines @@
         } else if (index != 0) {
           let key = dart.dsend(element, 'substring', 0, index);
           let value = dart.dsend(element, 'substring', dart.notNull(index) + 1);
           dart.dsetindex(map, Uri.decodeQueryComponent(dart.as(key, String), {encoding: encoding}), Uri.decodeQueryComponent(dart.as(value, String), {encoding: encoding}));
         }
         return map;
       })), Map$(String, String));
     }
     static parseIPv4Address(host) {
       function error(msg) {
-        throw new FormatException(`Illegal IPv4 address, ${msg}`);
+        dart.throw(new FormatException(`Illegal IPv4 address, ${msg}`));
       }
       dart.fn(error, dart.void, [String]);
       let bytes = host[dartx.split]('.');
       if (bytes[dartx.length] != 4) {
         error('IPv4 address should contain exactly 4 parts');
       }
       return dart.as(bytes[dartx.map](dart.fn(byteString => {
         let byte = int.parse(dart.as(byteString, String));
         if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
           error('each part must be in the range of `0..255`');
         }
         return byte;
       }))[dartx.toList](), List$(int));
     }
     static parseIPv6Address(host, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (end == null)
         end = host[dartx.length];
       function error(msg, position) {
         if (position === void 0)
           position = null;
-        throw new FormatException(`Illegal IPv6 address, ${msg}`, host, dart.as(position, int));
+        dart.throw(new FormatException(`Illegal IPv6 address, ${msg}`, host, dart.as(position, int)));
       }
       dart.fn(error, dart.void, [String], [dart.dynamic]);
       function parseHex(start, end) {
         if (dart.notNull(end) - dart.notNull(start) > 4) {
           error('an IPv6 part can only contain a maximum of 4 hex digits', start);
         }
         let value = int.parse(host[dartx.substring](start, end), {radix: 16});
         if (dart.notNull(value) < 0 || dart.notNull(value) > (1 << 16) - 1) {
           error('each part must be in the range of `0x0..0xFFFF`', start);
         }
@@ skipping 101 matching lines @@
       let byte = 0;
       for (let i = 0; dart.notNull(i) < 2; i = dart.notNull(i) + 1) {
         let charCode = s[dartx.codeUnitAt](dart.notNull(pos) + dart.notNull(i));
         if (48 <= dart.notNull(charCode) && dart.notNull(charCode) <= 57) {
           byte = dart.notNull(byte) * 16 + dart.notNull(charCode) - 48;
         } else {
           charCode = dart.notNull(charCode) | 32;
           if (97 <= dart.notNull(charCode) && dart.notNull(charCode) <= 102) {
             byte = dart.notNull(byte) * 16 + dart.notNull(charCode) - 87;
           } else {
-            throw new ArgumentError("Invalid URL encoding");
+            dart.throw(new ArgumentError("Invalid URL encoding"));
           }
         }
       }
       return byte;
     }
     static _uriDecode(text, opts) {
       let plusToSpace = opts && 'plusToSpace' in opts ? opts.plusToSpace : false;
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
       let simple = true;
       for (let i = 0; dart.notNull(i) < dart.notNull(text[dartx.length]) && dart.notNull(simple); i = dart.notNull(i) + 1) {
         let codeUnit = text[dartx.codeUnitAt](i);
         simple = codeUnit != Uri._PERCENT && codeUnit != Uri._PLUS;
       }
       let bytes = null;
       if (dart.notNull(simple)) {
         if (dart.equals(encoding, convert.UTF8) || dart.equals(encoding, convert.LATIN1)) {
           return text;
         } else {
           bytes = text[dartx.codeUnits];
         }
       } else {
         bytes = List$(int).new();
         for (let i = 0; dart.notNull(i) < dart.notNull(text[dartx.length]); i = dart.notNull(i) + 1) {
           let codeUnit = text[dartx.codeUnitAt](i);
           if (dart.notNull(codeUnit) > 127) {
-            throw new ArgumentError("Illegal percent encoding in URI");
+            dart.throw(new ArgumentError("Illegal percent encoding in URI"));
           }
           if (codeUnit == Uri._PERCENT) {
             if (dart.notNull(i) + 3 > dart.notNull(text[dartx.length])) {
-              throw new ArgumentError('Truncated URI');
+              dart.throw(new ArgumentError('Truncated URI'));
             }
             bytes[dartx.add](Uri._hexCharPairToByte(text, dart.notNull(i) + 1));
             i = dart.notNull(i) + 2;
           } else if (dart.notNull(plusToSpace) && codeUnit == Uri._PLUS) {
             bytes[dartx.add](Uri._SPACE);
           } else {
             bytes[dartx.add](codeUnit);
           }
         }
       }
@@ skipping 174 matching lines @@
   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;
 });