more care around generated names, fixes #60 #82 and #97

lib/runtime/dart/_js_helper.js

 var _js_helper;
 (function(exports) {
   'use strict';
   class NoSideEffects extends core.Object {
     NoSideEffects() {
     }
   }
   class NoThrows extends core.Object {
     NoThrows() {
     }
@@ skipping 47 matching lines @@
     }
     dart.defineNamedConstructor(ConstantMap, '_');
     return ConstantMap;
   });
   let ConstantMap = ConstantMap$(dart.dynamic, dart.dynamic);
   let _jsObject = Symbol('_jsObject');
   let _keys = Symbol('_keys');
   let _fetch = Symbol('_fetch');
   let ConstantStringMap$ = dart.generic(function(K, V) {
     class ConstantStringMap extends ConstantMap$(K, V) {
-      ConstantStringMap$_(length, $_jsObject, $_keys) {
+      ConstantStringMap$_(length, jsObject$, keys$) {
         this.length = length;
-        this[_jsObject] = $_jsObject;
-        this[_keys] = $_keys;
+        this[_jsObject] = jsObject$;
+        this[_keys] = keys$;
         super.ConstantMap$_();
       }
       containsValue(needle) {
         return this.values.any((value) => dart.equals(value, needle));
       }
       containsKey(key) {
         if (!(typeof key == string))
           return false;
         if (dart.equals('__proto__', key))
           return false;
@@ skipping 21 matching lines @@
         return new _internal.MappedIterable(this[_keys], dart.closureWrap(((key) => this[_fetch](key)).bind(this), "(K) → V"));
       }
     }
     dart.defineNamedConstructor(ConstantStringMap, '_');
     return ConstantStringMap;
   });
   let ConstantStringMap = ConstantStringMap$(dart.dynamic, dart.dynamic);
   let _protoValue = Symbol('_protoValue');
   let ConstantProtoMap$ = dart.generic(function(K, V) {
     class ConstantProtoMap extends ConstantStringMap$(K, V) {
-      ConstantProtoMap$_(length, jsObject, keys, $_protoValue) {
-        this[_protoValue] = $_protoValue;
+      ConstantProtoMap$_(length, jsObject, keys, protoValue) {
+        this[_protoValue] = protoValue;
         super.ConstantStringMap$_(dart.as(length, core.int), jsObject, dart.as(keys, core.List$(K)));
       }
       containsKey(key) {
         if (!(typeof key == string))
           return false;
         if (dart.equals('__proto__', key))
           return true;
         return jsHasOwnProperty(this[_jsObject], dart.as(key, core.String));
       }
       [_fetch](key) {
         return dart.equals('__proto__', key) ? this[_protoValue] : jsPropertyAccess(this[_jsObject], dart.as(key, core.String));
       }
     }
     dart.defineNamedConstructor(ConstantProtoMap, '_');
     return ConstantProtoMap;
   });
   let ConstantProtoMap = ConstantProtoMap$(dart.dynamic, dart.dynamic);
   let _map = Symbol('_map');
   let _ConstantMapKeyIterable$ = dart.generic(function(K) {
     class _ConstantMapKeyIterable extends collection.IterableBase$(K) {
-      _ConstantMapKeyIterable($_map) {
-        this[_map] = $_map;
+      _ConstantMapKeyIterable(map$) {
+        this[_map] = map$;
         super.IterableBase();
       }
       get iterator() {
         return this[_map][_keys].iterator;
       }
       get length() {
         return this[_map][_keys].length;
       }
     }
     return _ConstantMapKeyIterable;
   });
   let _ConstantMapKeyIterable = _ConstantMapKeyIterable$(dart.dynamic);
   let _jsData = Symbol('_jsData');
   let _getMap = Symbol('_getMap');
   let GeneralConstantMap$ = dart.generic(function(K, V) {
     class GeneralConstantMap extends ConstantMap$(K, V) {
-      GeneralConstantMap($_jsData) {
-        this[_jsData] = $_jsData;
+      GeneralConstantMap(jsData) {
+        this[_jsData] = jsData;
         super.ConstantMap$_();
       }
       [_getMap]() {
         if (!this.$map) {
           let backingMap = new collection.LinkedHashMap();
           this.$map = fillLiteralMap(this[_jsData], backingMap);
         }
         return this.$map;
       }
       containsValue(needle) {
@@ skipping 35 matching lines @@
   }
   // Function arraySet: (List<dynamic>, int, dynamic) → void
   function arraySet(array, index, value) {
     array[index] = value;
   }
   // Function propertyGet: (dynamic, String) → dynamic
   function propertyGet(object, property) {
     return object[property];
   }
   // Function callHasOwnProperty: (dynamic, dynamic, String) → bool
-  function callHasOwnProperty(function, object, property) {
-    return function.call(object, property);
+  function callHasOwnProperty(func, object, property) {
+    return func.call(object, property);
   }
   // Function propertySet: (dynamic, String, dynamic) → void
   function propertySet(object, property, value) {
     object[property] = value;
   }
   // Function getPropertyFromPrototype: (dynamic, String) → dynamic
   function getPropertyFromPrototype(object, name) {
     return Object.getPrototypeOf(object)[name];
   }
   exports.getTagFunction = null;
@@ skipping 245 matching lines @@
   let _nativeGlobalRegExp = Symbol('_nativeGlobalRegExp');
   let _nativeAnchoredRegExp = Symbol('_nativeAnchoredRegExp');
   let _isMultiLine = Symbol('_isMultiLine');
   let _isCaseSensitive = Symbol('_isCaseSensitive');
   let _execGlobal = Symbol('_execGlobal');
   let _execAnchored = Symbol('_execAnchored');
   class JSSyntaxRegExp extends core.Object {
     toString() {
       return `RegExp/${this.pattern}/`;
     }
-    JSSyntaxRegExp(source, opt$) {
-      let multiLine = opt$ && 'multiLine' in opt$ ? opt$.multiLine : false;
-      let caseSensitive = opt$ && 'caseSensitive' in opt$ ? opt$.caseSensitive : true;
+    JSSyntaxRegExp(source, opts) {
+      let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
+      let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
       this.pattern = source;
       this[_nativeRegExp] = makeNative(source, multiLine, caseSensitive, false);
       this[_nativeGlobalRegExp] = null;
       this[_nativeAnchoredRegExp] = null;
     }
     get [_nativeGlobalVersion]() {
       if (this[_nativeGlobalRegExp] !== null)
         return this[_nativeGlobalRegExp];
       return this[_nativeGlobalRegExp] = makeNative(this.pattern, this[_isMultiLine], this[_isCaseSensitive], true);
     }
@@ skipping 80 matching lines @@
     }
     get isMultiLine() {
       return this[_isMultiLine];
     }
     get isCaseSensitive() {
       return this[_isCaseSensitive];
     }
   }
   let _match = Symbol('_match');
   class _MatchImplementation extends core.Object {
-    _MatchImplementation(pattern, $_match) {
+    _MatchImplementation(pattern, match$) {
       this.pattern = pattern;
-      this[_match] = $_match;
+      this[_match] = match$;
       dart.assert(typeof this[_match].input == string);
       dart.assert(typeof this[_match].index == number);
     }
     get input() {
       return this[_match].input;
     }
     get start() {
       return this[_match].index;
     }
     get end() {
@@ skipping 13 matching lines @@
       for (let i of groups) {
         out.add(this.group(i));
       }
       return out;
     }
   }
   let _re = Symbol('_re');
   let _string = Symbol('_string');
   let _start = Symbol('_start');
   class _AllMatchesIterable extends collection.IterableBase$(core.Match) {
-    _AllMatchesIterable($_re, $_string, $_start) {
-      this[_re] = $_re;
-      this[_string] = $_string;
-      this[_start] = $_start;
+    _AllMatchesIterable(re$, string$, start$) {
+      this[_re] = re$;
+      this[_string] = string$;
+      this[_start] = start$;
       super.IterableBase();
     }
     get iterator() {
       return new _AllMatchesIterator(this[_re], this[_string], this[_start]);
     }
   }
   let _regExp = Symbol('_regExp');
   let _nextIndex = Symbol('_nextIndex');
   let _current = Symbol('_current');
   class _AllMatchesIterator extends core.Object {
-    _AllMatchesIterator($_regExp, $_string, $_nextIndex) {
-      this[_regExp] = $_regExp;
-      this[_string] = $_string;
-      this[_nextIndex] = $_nextIndex;
+    _AllMatchesIterator(regExp$, string$, nextIndex$) {
+      this[_regExp] = regExp$;
+      this[_string] = string$;
+      this[_nextIndex] = nextIndex$;
       this[_current] = null;
     }
     get current() {
       return this[_current];
     }
     moveNext() {
       if (this[_string] === null)
         return false;
       if (dart.notNull(this[_nextIndex]) <= dart.notNull(this[_string].length)) {
         let match = this[_regExp]._execGlobal(this[_string], this[_nextIndex]);
@@ skipping 219 matching lines @@
   function stringJoinUnchecked(array, separator) {
     return array.join(separator);
   }
   // Function createRuntimeType: (String) → Type
   function createRuntimeType(name) {
     return new TypeImpl(name);
   }
   let _typeName = Symbol('_typeName');
   let _unmangledName = Symbol('_unmangledName');
   class TypeImpl extends core.Object {
-    TypeImpl($_typeName) {
-      this[_typeName] = $_typeName;
+    TypeImpl(typeName$) {
+      this[_typeName] = typeName$;
       this[_unmangledName] = null;
     }
     toString() {
       if (this[_unmangledName] !== null)
         return this[_unmangledName];
       let unmangledName = _js_names.unmangleAllIdentifiersIfPreservedAnyways(this[_typeName]);
       return this[_unmangledName] = unmangledName;
     }
     get hashCode() {
       return this[_typeName].hashCode;
@@ skipping 43 matching lines @@
   }
   // Function copyTypeArguments: (Object, Object) → void
   function copyTypeArguments(source, target) {
     target.$builtinTypeInfo = source.$builtinTypeInfo;
   }
   // Function getClassName: (dynamic) → String
   function getClassName(object) {
     return _interceptors.getInterceptor(object).constructor.builtin$cls;
   }
   // Function getRuntimeTypeAsString: (dynamic, {onTypeVariable: (int) → String}) → String
-  function getRuntimeTypeAsString(runtimeType, opt$) {
-    let onTypeVariable = opt$ && 'onTypeVariable' in opt$ ? opt$.onTypeVariable : null;
+  function getRuntimeTypeAsString(runtimeType, opts) {
+    let onTypeVariable = opts && 'onTypeVariable' in opts ? opts.onTypeVariable : null;
     dart.assert(isJsArray(runtimeType));
     let className = getConstructorName(getIndex(runtimeType, 0));
     return `${className}` + `${joinArguments(runtimeType, 1, {onTypeVariable: onTypeVariable})}`;
   }
   // Function getConstructorName: (dynamic) → String
   function getConstructorName(type) {
     return type.builtin$cls;
   }
   // Function runtimeTypeToString: (dynamic, {onTypeVariable: (int) → String}) → String
-  function runtimeTypeToString(type, opt$) {
-    let onTypeVariable = opt$ && 'onTypeVariable' in opt$ ? opt$.onTypeVariable : null;
+  function runtimeTypeToString(type, opts) {
+    let onTypeVariable = opts && 'onTypeVariable' in opts ? opts.onTypeVariable : null;
     if (type === null) {
       return 'dynamic';
     } else if (isJsArray(type)) {
       return getRuntimeTypeAsString(type, {onTypeVariable: onTypeVariable});
     } else if (isJsFunction(type)) {
       return getConstructorName(type);
     } else if (typeof type == number) {
       if (onTypeVariable === null) {
         return dart.as(dart.dinvoke(type, 'toString'), core.String);
       } else {
         return onTypeVariable(dart.as(type, core.int));
       }
     } else {
       return null;
     }
   }
   // Function joinArguments: (dynamic, int, {onTypeVariable: (int) → String}) → String
-  function joinArguments(types, startIndex, opt$) {
-    let onTypeVariable = opt$ && 'onTypeVariable' in opt$ ? opt$.onTypeVariable : null;
+  function joinArguments(types, startIndex, opts) {
+    let onTypeVariable = opts && 'onTypeVariable' in opts ? opts.onTypeVariable : null;
     if (types === null)
       return '';
     dart.assert(isJsArray(types));
     let firstArgument = true;
     let allDynamic = true;
     let buffer = new core.StringBuffer();
     for (let index = startIndex; dart.notNull(index) < dart.notNull(getLength(types)); index = dart.notNull(index) + 1) {
       if (firstArgument) {
         firstArgument = false;
       } else {
@@ skipping 284 matching lines @@
         if (!dart.notNull(isAssignable(getIndex(sOptionalParameterTypes, sPos), getIndex(tOptionalParameterTypes, tPos)))) {
           return false;
         }
       }
     }
     let sNamedParameters = getField(s, `${_foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG()}`);
     let tNamedParameters = getField(t, `${_foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG()}`);
     return areAssignableMaps(sNamedParameters, tNamedParameters);
   }
   // Function invoke: (dynamic, dynamic) → dynamic
-  function invoke(function, arguments) {
-    return invokeOn(function, null, arguments);
+  function invoke(func, arguments) {
+    return invokeOn(func, null, arguments);
   }
   // Function invokeOn: (dynamic, dynamic, dynamic) → Object
-  function invokeOn(function, receiver, arguments) {
-    dart.assert(isJsFunction(function));
+  function invokeOn(func, receiver, arguments) {
+    dart.assert(isJsFunction(func));
     dart.assert(dart.notNull(arguments === null) || dart.notNull(isJsArray(arguments)));
-    return function.apply(receiver, arguments);
+    return func.apply(receiver, arguments);
   }
   // Function call: (dynamic, String) → dynamic
   function call(object, name) {
     return object[name]();
   }
   // Function getField: (dynamic, String) → dynamic
   function getField(object, name) {
     return object[name];
   }
   // Function getIndex: (dynamic, int) → dynamic
@@ skipping 96 matching lines @@
     }
   }
   let _memberName = Symbol('_memberName');
   let _internalName = Symbol('_internalName');
   let _kind = Symbol('_kind');
   let _arguments = Symbol('_arguments');
   let _namedArgumentNames = Symbol('_namedArgumentNames');
   let _namedIndices = Symbol('_namedIndices');
   let _getCachedInvocation = Symbol('_getCachedInvocation');
   class JSInvocationMirror extends core.Object {
-    JSInvocationMirror($_memberName, $_internalName, $_kind, $_arguments, $_namedArgumentNames) {
-      this[_memberName] = $_memberName;
-      this[_internalName] = $_internalName;
-      this[_kind] = $_kind;
-      this[_arguments] = $_arguments;
-      this[_namedArgumentNames] = $_namedArgumentNames;
+    JSInvocationMirror(memberName$, internalName$, kind$, arguments$, namedArgumentNames) {
+      this[_memberName] = memberName$;
+      this[_internalName] = internalName$;
+      this[_kind] = kind$;
+      this[_arguments] = arguments$;
+      this[_namedArgumentNames] = namedArgumentNames;
       this[_namedIndices] = null;
     }
     get memberName() {
       if (dart.is(this[_memberName], core.Symbol))
         return dart.as(this[_memberName], core.Symbol);
       let name = dart.as(this[_memberName], core.String);
       let unmangledName = _js_names.mangledNames.get(name);
       if (unmangledName !== null) {
         name = unmangledName.split(':').get(0);
       } else {
@@ skipping 249 matching lines @@
     }
     sortedIndex(unsortedIndex) {
       if (this.cachedSortedIndices === null) {
         this.cachedSortedIndices = new core.List(this.optionalParameterCount);
         let positions = dart.map();
         for (let i = 0; dart.notNull(i) < dart.notNull(this.optionalParameterCount); i = dart.notNull(i) + 1) {
           let index = dart.notNull(this.requiredParameterCount) + dart.notNull(i);
           positions.set(this.parameterName(index), index);
         }
         let index = 0;
-        ((_) => {
-          _.sort();
-          return _;
+        ((_$) => {
+          _$.sort();
+          return _$;
         }).bind(this)(positions.keys.toList()).forEach(((name) => {
-          this.cachedSortedIndices.set((($tmp) => index = dart.notNull($tmp) + 1, $tmp)(index), positions.get(name));
+          this.cachedSortedIndices.set(((x) => index = dart.notNull(x$) + 1, x$)(index), positions.get(name));
         }).bind(this));
       }
       return dart.as(this.cachedSortedIndices.get(unsortedIndex), core.int);
     }
     computeFunctionRti(jsConstructor) {
       if (typeof this.functionType == "number") {
         return getMetadata(dart.as(this.functionType, core.int));
       } else if (typeof this.functionType == "function") {
         let fakeInstance = new jsConstructor();
         setRuntimeTypeInfo(fakeInstance, fakeInstance["<>"]);
         return this.functionType.apply({$receiver: fakeInstance});
       } else {
         throw new RuntimeError('Unexpected function type');
       }
     }
     get reflectionName() {
       return this.jsFunction.$reflectionName;
     }
   }
   dart.defineNamedConstructor(ReflectionInfo, 'internal');
   ReflectionInfo.REQUIRED_PARAMETERS_INFO = 0;
   ReflectionInfo.OPTIONAL_PARAMETERS_INFO = 1;
   ReflectionInfo.FUNCTION_TYPE_INDEX = 2;
   ReflectionInfo.FIRST_DEFAULT_ARGUMENT = 3;
   // Function getMetadata: (int) → dynamic
   function getMetadata(index) {
     let metadata = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.METADATA);
     return metadata[index];
   }
-  let _throwFormatException = Symbol('_throwFormatException');
-  let _fromCharCodeApply = Symbol('_fromCharCodeApply');
+  let _throwFormatException$ = Symbol('_throwFormatException');
+  let _fromCharCodeApply$ = Symbol('_fromCharCodeApply');
   let _mangledNameMatchesType = Symbol('_mangledNameMatchesType');
   class Primitives extends core.Object {
     static initializeStatics(id) {
       mirrorFunctionCacheName = `_${id}`;
       mirrorInvokeCacheName = `_${id}`;
     }
     static objectHashCode(object) {
       let hash = dart.as(object.$identityHash, core.int);
       if (hash === null) {
         hash = Math.random() * 0x3fffffff | 0;
         object.$identityHash = hash;
       }
       return hash;
     }
-    static [_throwFormatException](string) {
+    static [_throwFormatException$](string) {
       throw new core.FormatException(string);
     }
     static parseInt(source, radix, handleError) {
       if (handleError === null)
         handleError = dart.closureWrap(_throwFormatException, "(String) → int");
       checkString(source);
       let match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source);
       let digitsIndex = 1;
       let hexIndex = 2;
       let decimalIndex = 3;
@@ skipping 104 matching lines @@
     static get isJsshell() {
       return typeof version == "function" && typeof system == "function";
     }
     static currentUri() {
       requiresPreamble();
       if (!!self.location) {
         return self.location.href;
       }
       return null;
     }
-    static [_fromCharCodeApply](array) {
+    static [_fromCharCodeApply$](array) {
       let result = "";
       let kMaxApply = 500;
       let end = array.length;
       for (let i = 0; dart.notNull(i) < dart.notNull(end); i = kMaxApply) {
         let subarray = null;
         if (dart.notNull(end) <= dart.notNull(kMaxApply)) {
           subarray = array;
         } else {
           subarray = array.slice(i, dart.notNull(i) + dart.notNull(kMaxApply) < dart.notNull(end) ? dart.notNull(i) + dart.notNull(kMaxApply) : end);
         }
@@ skipping 141 matching lines @@
         throw new core.ArgumentError(object);
       }
       return object[key];
     }
     static setProperty(object, key, value) {
       if (dart.notNull(object === null) || dart.notNull(typeof object == boolean) || dart.notNull(dart.is(object, core.num)) || dart.notNull(typeof object == string)) {
         throw new core.ArgumentError(object);
       }
       object[key] = value;
     }
-    static functionNoSuchMethod(function, positionalArguments, namedArguments) {
+    static functionNoSuchMethod(func, positionalArguments, namedArguments) {
       let argumentCount = 0;
       let arguments = new List.from([]);
       let namedArgumentList = new List.from([]);
       if (positionalArguments !== null) {
         argumentCount = positionalArguments.length;
         arguments.addAll(positionalArguments);
       }
       let names = '';
       if (dart.notNull(namedArguments !== null) && !dart.notNull(namedArguments.isEmpty)) {
         namedArguments.forEach(((name, argument) => {
           names = `${names}$${name}`;
           namedArgumentList.add(name);
           arguments.add(argument);
           argumentCount = dart.notNull(argumentCount) + 1;
         }).bind(this));
       }
       let selectorName = `${_foreign_helper.JS_GET_NAME("CALL_PREFIX")}$${argumentCount}${names}`;
-      return dart.dinvoke(function, 'noSuchMethod', createUnmangledInvocationMirror(dart.throw_("Unimplemented SymbolLiteral: #call"), selectorName, JSInvocationMirror.METHOD, arguments, namedArgumentList));
+      return dart.dinvoke(func, 'noSuchMethod', createUnmangledInvocationMirror(dart.throw_("Unimplemented SymbolLiteral: #call"), selectorName, JSInvocationMirror.METHOD, arguments, namedArgumentList));
     }
-    static applyFunction(function, positionalArguments, namedArguments) {
-      return namedArguments === null ? applyFunctionWithPositionalArguments(function, positionalArguments) : applyFunctionWithNamedArguments(function, positionalArguments, namedArguments);
+    static applyFunction(func, positionalArguments, namedArguments) {
+      return namedArguments === null ? applyFunctionWithPositionalArguments(func, positionalArguments) : applyFunctionWithNamedArguments(func, positionalArguments, namedArguments);
     }
-    static applyFunctionWithPositionalArguments(function, positionalArguments) {
+    static applyFunctionWithPositionalArguments(func, positionalArguments) {
       let argumentCount = 0;
       let arguments = null;
       if (positionalArguments !== null) {
         if (positionalArguments instanceof Array) {
           arguments = positionalArguments;
         } else {
           arguments = new core.List.from(positionalArguments);
         }
         argumentCount = arguments.length;
       } else {
         arguments = new List.from([]);
       }
       let selectorName = `${_foreign_helper.JS_GET_NAME("CALL_PREFIX")}$${argumentCount}`;
-      let jsFunction = function[selectorName];
+      let jsFunction = func[selectorName];
       if (jsFunction === null) {
-        return functionNoSuchMethod(function, positionalArguments, null);
+        return functionNoSuchMethod(func, positionalArguments, null);
       }
-      return jsFunction.apply(function, arguments);
+      return jsFunction.apply(func, arguments);
     }
-    static applyFunctionWithNamedArguments(function, positionalArguments, namedArguments) {
+    static applyFunctionWithNamedArguments(func, positionalArguments, namedArguments) {
       if (namedArguments.isEmpty) {
-        return applyFunctionWithPositionalArguments(function, positionalArguments);
+        return applyFunctionWithPositionalArguments(func, positionalArguments);
       }
-      let interceptor = _interceptors.getInterceptor(function);
+      let interceptor = _interceptors.getInterceptor(func);
       let jsFunction = interceptor["call*"];
       if (jsFunction === null) {
-        return functionNoSuchMethod(function, positionalArguments, namedArguments);
+        return functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       let info = new ReflectionInfo(jsFunction);
       if (dart.notNull(info === null) || !dart.notNull(info.areOptionalParametersNamed)) {
-        return functionNoSuchMethod(function, positionalArguments, namedArguments);
+        return functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       if (positionalArguments !== null) {
         positionalArguments = new core.List.from(positionalArguments);
       } else {
         positionalArguments = new List.from([]);
       }
       if (info.requiredParameterCount !== positionalArguments.length) {
-        return functionNoSuchMethod(function, positionalArguments, namedArguments);
+        return functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       let defaultArguments = new core.Map();
       for (let i = 0; dart.notNull(i) < dart.notNull(info.optionalParameterCount); i = dart.notNull(i) + 1) {
         let index = dart.notNull(i) + dart.notNull(info.requiredParameterCount);
         let parameterName = info.parameterNameInOrder(index);
         let value = info.defaultValueInOrder(index);
         let defaultValue = getMetadata(value);
         defaultArguments.set(parameterName, defaultValue);
       }
       let bad = false;
       namedArguments.forEach(((parameter, value) => {
         if (defaultArguments.containsKey(parameter)) {
           defaultArguments.set(parameter, value);
         } else {
           bad = true;
         }
       }).bind(this));
       if (bad) {
-        return functionNoSuchMethod(function, positionalArguments, namedArguments);
+        return functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       positionalArguments.addAll(defaultArguments.values);
-      return jsFunction.apply(function, positionalArguments);
+      return jsFunction.apply(func, positionalArguments);
     }
     static [_mangledNameMatchesType](mangledName, type) {
       return mangledName == type[_typeName];
     }
     static identicalImplementation(a, b) {
       return a == null ? b == null : a === b;
     }
     static extractStackTrace(error) {
       return getTraceFromException(error.$thrownJsError);
     }
@@ skipping 102 matching lines @@
   // Function throwAbstractClassInstantiationError: (dynamic) → dynamic
   function throwAbstractClassInstantiationError(className) {
     throw new core.AbstractClassInstantiationError(dart.as(className, core.String));
   }
   let _argumentsExpr = Symbol('_argumentsExpr');
   let _expr = Symbol('_expr');
   let _method = Symbol('_method');
   let _receiver = Symbol('_receiver');
   let _pattern = Symbol('_pattern');
   class TypeErrorDecoder extends core.Object {
-    TypeErrorDecoder($_arguments, $_argumentsExpr, $_expr, $_method, $_receiver, $_pattern) {
-      this[_arguments] = $_arguments;
-      this[_argumentsExpr] = $_argumentsExpr;
-      this[_expr] = $_expr;
-      this[_method] = $_method;
-      this[_receiver] = $_receiver;
-      this[_pattern] = $_pattern;
+    TypeErrorDecoder(arguments$, argumentsExpr$, expr$, method$, receiver$, pattern$) {
+      this[_arguments] = arguments$;
+      this[_argumentsExpr] = argumentsExpr$;
+      this[_expr] = expr$;
+      this[_method] = method$;
+      this[_receiver] = receiver$;
+      this[_pattern] = pattern$;
     }
     matchTypeError(message) {
       let match = new RegExp(this[_pattern]).exec(message);
       if (match === null)
         return null;
       let result = Object.create(null);
       if (this[_arguments] !== -1) {
         result.arguments = match[this[_arguments] + 1];
       }
       if (this[_argumentsExpr] !== -1) {
@@ skipping 33 matching lines @@
         match = dart.as(new List.from([]), core.List$(core.String));
       let arguments = match.indexOf('\\$arguments\\$');
       let argumentsExpr = match.indexOf('\\$argumentsExpr\\$');
       let expr = match.indexOf('\\$expr\\$');
       let method = match.indexOf('\\$method\\$');
       let receiver = match.indexOf('\\$receiver\\$');
       let pattern = message.replace('\\$arguments\\$', '((?:x|[^x])*)').replace('\\$argumentsExpr\\$', '((?:x|[^x])*)').replace('\\$expr\\$', '((?:x|[^x])*)').replace('\\$method\\$', '((?:x|[^x])*)').replace('\\$receiver\\$', '((?:x|[^x])*)');
       return new TypeErrorDecoder(arguments, argumentsExpr, expr, method, receiver, pattern);
     }
     static provokeCallErrorOn(expression) {
-      let function = function($expr$) {
+      let func = function($expr$) {
         var $argumentsExpr$ = '$arguments$';
         try {
           $expr$.$method$($argumentsExpr$);
         } catch (e) {
           return e.message;
         }
 
       };
-      return function(expression);
+      return func(expression);
     }
     static provokeCallErrorOnNull() {
-      let function = function() {
+      let func = function() {
         var $argumentsExpr$ = '$arguments$';
         try {
           null.$method$($argumentsExpr$);
         } catch (e) {
           return e.message;
         }
 
       };
-      return function();
+      return func();
     }
     static provokeCallErrorOnUndefined() {
-      let function = function() {
+      let func = function() {
         var $argumentsExpr$ = '$arguments$';
         try {
           (void 0).$method$($argumentsExpr$);
         } catch (e) {
           return e.message;
         }
 
       };
-      return function();
+      return func();
     }
     static provokePropertyErrorOn(expression) {
-      let function = function($expr$) {
+      let func = function($expr$) {
         try {
           $expr$.$method$;
         } catch (e) {
           return e.message;
         }
 
       };
-      return function(expression);
+      return func(expression);
     }
     static provokePropertyErrorOnNull() {
-      let function = function() {
+      let func = function() {
         try {
           null.$method$;
         } catch (e) {
           return e.message;
         }
 
       };
-      return function();
+      return func();
     }
     static provokePropertyErrorOnUndefined() {
-      let function = function() {
+      let func = function() {
         try {
           (void 0).$method$;
         } catch (e) {
           return e.message;
         }
 
       };
-      return function();
+      return func();
     }
   }
   dart.defineLazyProperties(TypeErrorDecoder, {
     get noSuchMethodPattern() {
       return dart.as(extractPattern(provokeCallErrorOn(buildJavaScriptObject())), TypeErrorDecoder);
     },
     get notClosurePattern() {
       return dart.as(extractPattern(provokeCallErrorOn(buildJavaScriptObjectWithNonClosure())), TypeErrorDecoder);
     },
     get nullCallPattern() {
@@ skipping 16 matching lines @@
     },
     get undefinedPropertyPattern() {
       return dart.as(extractPattern(provokePropertyErrorOn(void 0)), TypeErrorDecoder);
     },
     get undefinedLiteralPropertyPattern() {
       return dart.as(extractPattern(provokePropertyErrorOnUndefined()), TypeErrorDecoder);
     }
   });
   let _message = Symbol('_message');
   class NullError extends core.Error {
-    NullError($_message, match) {
-      this[_message] = $_message;
+    NullError(message$, match) {
+      this[_message] = message$;
       this[_method] = dart.as(match === null ? null : match.method, core.String);
       super.Error();
     }
     toString() {
       if (this[_method] === null)
         return `NullError: ${this[_message]}`;
       return `NullError: Cannot call "${this[_method]}" on null`;
     }
   }
   class JsNoSuchMethodError extends core.Error {
-    JsNoSuchMethodError($_message, match) {
-      this[_message] = $_message;
+    JsNoSuchMethodError(message$, match) {
+      this[_message] = message$;
       this[_method] = dart.as(match === null ? null : match.method, core.String);
       this[_receiver] = dart.as(match === null ? null : match.receiver, core.String);
       super.Error();
     }
     toString() {
       if (this[_method] === null)
         return `NoSuchMethodError: ${this[_message]}`;
       if (this[_receiver] === null) {
         return `NoSuchMethodError: Cannot call "${this[_method]}" (${this[_message]})`;
       }
       return `NoSuchMethodError: Cannot call "${this[_method]}" on "${this[_receiver]}" ` + `(${this[_message]})`;
     }
   }
   class UnknownJsTypeError extends core.Error {
-    UnknownJsTypeError($_message) {
-      this[_message] = $_message;
+    UnknownJsTypeError(message$) {
+      this[_message] = message$;
       super.Error();
     }
     toString() {
       return this[_message].isEmpty ? 'Error' : `Error: ${this[_message]}`;
     }
   }
   // Function unwrapException: (dynamic) → dynamic
   function unwrapException(ex) {
     // Function saveStackTrace: (dynamic) → dynamic
     function saveStackTrace(error) {
@@ skipping 64 matching lines @@
     }
     return ex;
   }
   // Function getTraceFromException: (dynamic) → StackTrace
   function getTraceFromException(exception) {
     return new _StackTrace(exception);
   }
   let _exception = Symbol('_exception');
   let _trace = Symbol('_trace');
   class _StackTrace extends core.Object {
-    _StackTrace($_exception) {
-      this[_exception] = $_exception;
+    _StackTrace(exception$) {
+      this[_exception] = exception$;
       this[_trace] = null;
     }
     toString() {
       if (this[_trace] !== null)
         return this[_trace];
       let trace = null;
       if (typeof this[_exception] === "object") {
         trace = dart.as(this[_exception].stack, core.String);
       }
       return this[_trace] = trace === null ? '' : trace;
     }
   }
   // Function objectHashCode: (dynamic) → int
   function objectHashCode(object) {
     if (dart.notNull(object === null) || typeof object != 'object') {
       return dart.as(dart.dload(object, 'hashCode'), core.int);
     } else {
       return Primitives.objectHashCode(object);
     }
   }
   // Function fillLiteralMap: (dynamic, Map<dynamic, dynamic>) → dynamic
   function fillLiteralMap(keyValuePairs, result) {
     let index = 0;
     let length = getLength(keyValuePairs);
     while (dart.notNull(index) < dart.notNull(length)) {
-      let key = getIndex(keyValuePairs, (($tmp) => index = dart.notNull($tmp) + 1, $tmp)(index));
-      let value = getIndex(keyValuePairs, (($tmp) => index = dart.notNull($tmp) + 1, $tmp)(index));
+      let key = getIndex(keyValuePairs, ((x) => index = dart.notNull(x$) + 1, x$)(index));
+      let value = getIndex(keyValuePairs, ((x) => index = dart.notNull(x$) + 1, x$)(index));
       result.set(key, value);
     }
     return result;
   }
   // Function invokeClosure: (Function, dynamic, int, dynamic, dynamic, dynamic, dynamic) → dynamic
   function invokeClosure(closure, isolate, numberOfArguments, arg1, arg2, arg3, arg4) {
     if (numberOfArguments === 0) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, () => dart.dinvokef(closure));
     } else if (numberOfArguments === 1) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, () => dart.dinvokef(closure, arg1));
     } else if (numberOfArguments === 2) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, () => dart.dinvokef(closure, arg1, arg2));
     } else if (numberOfArguments === 3) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, () => dart.dinvokef(closure, arg1, arg2, arg3));
     } else if (numberOfArguments === 4) {
       return _foreign_helper.JS_CALL_IN_ISOLATE(isolate, () => dart.dinvokef(closure, arg1, arg2, arg3, arg4));
     } else {
       throw new core.Exception('Unsupported number of arguments for wrapped closure');
     }
   }
   // Function convertDartClosureToJS: (dynamic, int) → dynamic
   function convertDartClosureToJS(closure, arity) {
     if (closure === null)
       return null;
-    let function = closure.$identity;
-    if (!!function)
-      return function;
-    function = function(closure, arity, context, invoke) {
+    let func = closure.$identity;
+    if (!!func)
+      return func;
+    func = function(closure, arity, context, invoke) {
       return function(a1, a2, a3, a4) {
         return invoke(closure, context, arity, a1, a2, a3, a4);
       };
     }(closure, arity, _foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _foreign_helper.DART_CLOSURE_TO_JS(invokeClosure));
-    closure.$identity = function;
-    return function;
+    closure.$identity = func;
+    return func;
   }
   class Closure extends core.Object {
     Closure() {
     }
     static fromTearOff(receiver, functions, reflectionInfo, isStatic, jsArguments, propertyName) {
       _foreign_helper.JS_EFFECT(() => {
         BoundClosure.receiverOf(dart.as(void 0, BoundClosure));
         BoundClosure.selfOf(dart.as(void 0, BoundClosure));
       });
-      let function = functions[0];
-      let name = dart.as(function.$stubName, core.String);
-      let callName = dart.as(function.$callName, core.String);
-      function.$reflectionInfo = reflectionInfo;
-      let info = new ReflectionInfo(function);
+      let func = functions[0];
+      let name = dart.as(func.$stubName, core.String);
+      let callName = dart.as(func.$callName, core.String);
+      func.$reflectionInfo = reflectionInfo;
+      let info = new ReflectionInfo(func);
       let functionType = info.functionType;
       let prototype = isStatic ? Object.create(new TearOffClosure().constructor.prototype) : Object.create(new BoundClosure(null, null, null, null).constructor.prototype);
       prototype.$initialize = prototype.constructor;
       let constructor = isStatic ? function() {
         this.$initialize();
       } : isCsp ? function(a, b, c, d) {
         this.$initialize(a, b, c, d);
-      } : new Function("a", "b", "c", "d", "this.$initialize(a,b,c,d);" + (($tmp) => functionCounter = dart.notNull($tmp) + 1, $tmp)(functionCounter));
+      } : new Function("a", "b", "c", "d", "this.$initialize(a,b,c,d);" + ((x) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter));
       prototype.constructor = constructor;
       constructor.prototype = prototype;
-      let trampoline = function;
+      let trampoline = func;
       let isIntercepted = false;
       if (!dart.notNull(isStatic)) {
         if (jsArguments.length == 1) {
           isIntercepted = true;
         }
-        trampoline = forwardCallTo(receiver, function, isIntercepted);
+        trampoline = forwardCallTo(receiver, func, isIntercepted);
         trampoline.$reflectionInfo = reflectionInfo;
       } else {
         prototype.$name = propertyName;
       }
       let signatureFunction = null;
       if (typeof functionType == "number") {
         let metadata = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.METADATA);
         signatureFunction = function(s) {
           return function() {
             return metadata[s];
@@ skipping 14 matching lines @@
       for (let i = 1; dart.notNull(i) < dart.notNull(functions.length); i = dart.notNull(i) + 1) {
         let stub = functions.get(i);
         let stubCallName = stub.$callName;
         if (stubCallName !== null) {
           prototype[stubCallName] = isStatic ? stub : forwardCallTo(receiver, stub, isIntercepted);
         }
       }
       prototype["call*"] = trampoline;
       return constructor;
     }
-    static cspForwardCall(arity, isSuperCall, stubName, function) {
+    static cspForwardCall(arity, isSuperCall, stubName, func) {
       let getSelf = _foreign_helper.RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
       if (isSuperCall)
         arity = -1;
       switch (arity) {
         case 0:
           return function(n, S) {
             return function() {
               return S(this)[n]();
             };
           }(stubName, getSelf);
@@ skipping 25 matching lines @@
           return function(n, S) {
             return function(a, b, c, d, e) {
               return S(this)[n](a, b, c, d, e);
             };
           }(stubName, getSelf);
         default:
           return function(f, s) {
             return function() {
               return f.apply(s(this), arguments);
             };
-          }(function, getSelf);
+          }(func, getSelf);
       }
     }
     static get isCsp() {
       return typeof dart_precompiled == "function";
     }
-    static forwardCallTo(receiver, function, isIntercepted) {
+    static forwardCallTo(receiver, func, isIntercepted) {
       if (isIntercepted)
-        return forwardInterceptedCallTo(receiver, function);
-      let stubName = dart.as(function.$stubName, core.String);
-      let arity = function.length;
+        return forwardInterceptedCallTo(receiver, func);
+      let stubName = dart.as(func.$stubName, core.String);
+      let arity = func.length;
       let lookedUpFunction = receiver[stubName];
-      let isSuperCall = !dart.notNull(core.identical(function, lookedUpFunction));
+      let isSuperCall = !dart.notNull(core.identical(func, lookedUpFunction));
       if (dart.notNull(isCsp) || dart.notNull(isSuperCall) || dart.notNull(arity) >= 27) {
-        return cspForwardCall(arity, isSuperCall, stubName, function);
+        return cspForwardCall(arity, isSuperCall, stubName, func);
       }
       if (arity === 0) {
-        return new Function('return function(){' + `return this.${BoundClosure.selfFieldName()}.${stubName}();` + `${(($tmp) => functionCounter = dart.notNull($tmp) + 1, $tmp)(functionCounter)}` + '}')();
+        return new Function('return function(){' + `return this.${BoundClosure.selfFieldName()}.${stubName}();` + `${((x) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter)}` + '}')();
       }
       dart.assert(1 <= dart.notNull(arity) && dart.notNull(arity) < 27);
       let arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity).join(",");
-      return new Function(`return function(${arguments}){` + `return this.${BoundClosure.selfFieldName()}.${stubName}(${arguments});` + `${(($tmp) => functionCounter = dart.notNull($tmp) + 1, $tmp)(functionCounter)}` + '}')();
+      return new Function(`return function(${arguments}){` + `return this.${BoundClosure.selfFieldName()}.${stubName}(${arguments});` + `${((x) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter)}` + '}')();
     }
-    static cspForwardInterceptedCall(arity, isSuperCall, name, function) {
+    static cspForwardInterceptedCall(arity, isSuperCall, name, func) {
       let getSelf = _foreign_helper.RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
       let getReceiver = _foreign_helper.RAW_DART_FUNCTION_REF(BoundClosure.receiverOf);
       if (isSuperCall)
         arity = -1;
       switch (arity) {
         case 0:
           throw new RuntimeError('Intercepted function with no arguments.');
         case 1:
           return function(n, s, r) {
             return function() {
@@ skipping 30 matching lines @@
               return s(this)[n](r(this), a, b, c, d, e);
             };
           }(name, getSelf, getReceiver);
         default:
           return function(f, s, r, a) {
             return function() {
               a = [r(this)];
               Array.prototype.push.apply(a, arguments);
               return f.apply(s(this), a);
             };
-          }(function, getSelf, getReceiver);
+          }(func, getSelf, getReceiver);
       }
     }
-    static forwardInterceptedCallTo(receiver, function) {
+    static forwardInterceptedCallTo(receiver, func) {
       let selfField = BoundClosure.selfFieldName();
       let receiverField = BoundClosure.receiverFieldName();
-      let stubName = dart.as(function.$stubName, core.String);
-      let arity = function.length;
+      let stubName = dart.as(func.$stubName, core.String);
+      let arity = func.length;
       let isCsp = typeof dart_precompiled == "function";
       let lookedUpFunction = receiver[stubName];
-      let isSuperCall = !dart.notNull(core.identical(function, lookedUpFunction));
+      let isSuperCall = !dart.notNull(core.identical(func, lookedUpFunction));
       if (dart.notNull(isCsp) || dart.notNull(isSuperCall) || dart.notNull(arity) >= 28) {
-        return cspForwardInterceptedCall(arity, isSuperCall, stubName, function);
+        return cspForwardInterceptedCall(arity, isSuperCall, stubName, func);
       }
       if (arity === 1) {
-        return new Function('return function(){' + `return this.${selfField}.${stubName}(this.${receiverField});` + `${(($tmp) => functionCounter = dart.notNull($tmp) + 1, $tmp)(functionCounter)}` + '}')();
+        return new Function('return function(){' + `return this.${selfField}.${stubName}(this.${receiverField});` + `${((x) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter)}` + '}')();
       }
       dart.assert(1 < dart.notNull(arity) && dart.notNull(arity) < 28);
       let arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, dart.notNull(arity) - 1).join(",");
-      return new Function(`return function(${arguments}){` + `return this.${selfField}.${stubName}(this.${receiverField}, ${arguments});` + `${(($tmp) => functionCounter = dart.notNull($tmp) + 1, $tmp)(functionCounter)}` + '}')();
+      return new Function(`return function(${arguments}){` + `return this.${selfField}.${stubName}(this.${receiverField}, ${arguments});` + `${((x) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter)}` + '}')();
     }
     toString() {
       return "Closure";
     }
   }
   Closure.FUNCTION_INDEX = 0;
   Closure.NAME_INDEX = 1;
   Closure.CALL_NAME_INDEX = 2;
   Closure.REQUIRED_PARAMETER_INDEX = 3;
   Closure.OPTIONAL_PARAMETER_INDEX = 4;
   Closure.DEFAULT_ARGUMENTS_INDEX = 5;
   Closure.functionCounter = 0;
   // Function closureFromTearOff: (dynamic, dynamic, dynamic, dynamic, dynamic, dynamic) → dynamic
   function closureFromTearOff(receiver, functions, reflectionInfo, isStatic, jsArguments, name) {
     return Closure.fromTearOff(receiver, _interceptors.JSArray.markFixedList(dart.as(functions, core.List)), _interceptors.JSArray.markFixedList(dart.as(reflectionInfo, core.List)), !!isStatic, jsArguments, name);
   }
   class TearOffClosure extends Closure {
   }
   let _self = Symbol('_self');
   let _target = Symbol('_target');
   let _name = Symbol('_name');
   class BoundClosure extends TearOffClosure {
-    BoundClosure($_self, $_target, $_receiver, $_name) {
-      this[_self] = $_self;
-      this[_target] = $_target;
-      this[_receiver] = $_receiver;
-      this[_name] = $_name;
+    BoundClosure(self$, target$, receiver$, name$) {
+      this[_self] = self$;
+      this[_target] = target$;
+      this[_receiver] = receiver$;
+      this[_name] = name$;
       super.TearOffClosure();
     }
     ['=='](other) {
       if (core.identical(this, other))
         return true;
       if (!dart.is(other, BoundClosure))
         return false;
       return this[_self] === dart.dload(other, '_self') && this[_target] === dart.dload(other, '_target') && this[_receiver] === dart.dload(other, '_receiver');
     }
     get hashCode() {
@@ skipping 681 matching lines @@
   let _hasReturnType = Symbol('_hasReturnType');
   let _returnType = Symbol('_returnType');
   let _isVoid = Symbol('_isVoid');
   let _hasArguments = Symbol('_hasArguments');
   let _hasOptionalArguments = Symbol('_hasOptionalArguments');
   let _optionalArguments = Symbol('_optionalArguments');
   let _hasNamedArguments = Symbol('_hasNamedArguments');
   let _namedArguments = Symbol('_namedArguments');
   let _convert = Symbol('_convert');
   class FunctionTypeInfoDecoderRing extends core.Object {
-    FunctionTypeInfoDecoderRing($_typeData) {
-      this[_typeData] = $_typeData;
+    FunctionTypeInfoDecoderRing(typeData) {
+      this[_typeData] = typeData;
       this[_cachedToString] = null;
     }
     get [_hasReturnType]() {
       return "ret" in this[_typeData];
     }
     get [_returnType]() {
       return this[_typeData].ret;
     }
     get [_isVoid]() {
-      return !!this[_typeData]["void"];
+      return !!this[_typeData].void;
     }
     get [_hasArguments]() {
       return "args" in this[_typeData];
     }
     get [_arguments]() {
       return dart.as(this[_typeData].args, core.List);
     }
     get [_hasOptionalArguments]() {
       return "opt" in this[_typeData];
     }
@@ skipping 57 matching lines @@
         s = 'void';
       } else if (this[_hasReturnType]) {
         s = this[_convert](this[_returnType]);
       } else {
         s = 'dynamic';
       }
       return this[_cachedToString] = `${s}`;
     }
   }
   class UnimplementedNoSuchMethodError extends core.Error {
-    UnimplementedNoSuchMethodError($_message) {
-      this[_message] = $_message;
+    UnimplementedNoSuchMethodError(message$) {
+      this[_message] = message$;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this[_message]}`;
     }
   }
   // Function random64: () → int
   function random64() {
     let int32a = Math.random() * 0x100000000 >>> 0;
     let int32b = Math.random() * 0x100000000 >>> 0;
@@ skipping 110 matching lines @@
         completer.complete(null);
       }, 1), false);
       script.addEventListener("error", convertDartClosureToJS((event) => {
         completer.completeError(new async.DeferredLoadException(`Loading ${uri} failed.`));
       }, 1), false);
       document.body.appendChild(script);
       return completer.future;
     }));
   }
   class MainError extends core.Error {
-    MainError($_message) {
-      this[_message] = $_message;
+    MainError(message$) {
+      this[_message] = message$;
       super.Error();
     }
     toString() {
       return `NoSuchMethodError: ${this[_message]}`;
     }
   }
   // Function missingMain: () → void
   function missingMain() {
     throw new MainError("No top-level function named 'main'.");
   }
@@ skipping 227 matching lines @@
   exports.UnimplementedNoSuchMethodError = UnimplementedNoSuchMethodError;
   exports.random64 = random64;
   exports.jsonEncodeNative = jsonEncodeNative;
   exports.getIsolateAffinityTag = getIsolateAffinityTag;
   exports.loadDeferredLibrary = loadDeferredLibrary;
   exports.MainError = MainError;
   exports.missingMain = missingMain;
   exports.badMain = badMain;
   exports.mainHasTooManyParameters = mainHasTooManyParameters;
 })(_js_helper || (_js_helper = {}));