Rewire DDC to use the analyzer task model

lib/runtime/dart/_js_helper.js

 dart_library.library('dart/_js_helper', null, /* Imports */[
   "dart_runtime/dart",
   'dart/core',
   'dart/collection',
   'dart/_interceptors',
   'dart/_foreign_helper'
 ], /* Lazy imports */[
 ], function(exports, dart, core, collection, _interceptors, _foreign_helper) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 74 matching lines @@
   let _execGlobal = Symbol('_execGlobal');
   let _execAnchored = Symbol('_execAnchored');
   class JSSyntaxRegExp extends core.Object {
     toString() {
       return `RegExp/${this.pattern}/`;
     }
     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] = JSSyntaxRegExp.makeNative(source, multiLine, caseSensitive, false);
+      this[_nativeRegExp] = dart.dcall(JSSyntaxRegExp.makeNative, source, multiLine, caseSensitive, false);
       this[_nativeGlobalRegExp] = null;
       this[_nativeAnchoredRegExp] = null;
     }
     get [_nativeGlobalVersion]() {
       if (this[_nativeGlobalRegExp] != null)
         return this[_nativeGlobalRegExp];
-      return this[_nativeGlobalRegExp] = JSSyntaxRegExp.makeNative(this.pattern, this[_isMultiLine], this[_isCaseSensitive], true);
+      return this[_nativeGlobalRegExp] = dart.dcall(JSSyntaxRegExp.makeNative, this.pattern, this[_isMultiLine], this[_isCaseSensitive], true);
     }
     get [_nativeAnchoredVersion]() {
       if (this[_nativeAnchoredRegExp] != null)
         return this[_nativeAnchoredRegExp];
-      return this[_nativeAnchoredRegExp] = JSSyntaxRegExp.makeNative(`${this.pattern}|()`, this[_isMultiLine], this[_isCaseSensitive], true);
+      return this[_nativeAnchoredRegExp] = dart.dcall(JSSyntaxRegExp.makeNative, `${this.pattern}|()`, this[_isMultiLine], this[_isCaseSensitive], true);
     }
     get [_isMultiLine]() {
-      return this[_nativeRegExp].multiline;
+      return dart.as(this[_nativeRegExp].multiline, core.bool);
     }
     get [_isCaseSensitive]() {
-      return !this[_nativeRegExp].ignoreCase;
+      return dart.as(!this[_nativeRegExp].ignoreCase, core.bool);
     }
     static makeNative(source, multiLine, caseSensitive, global) {
-      checkString(source);
+      dart.dcall(checkString, source);
       let m = dart.notNull(multiLine) ? 'm' : '';
       let i = dart.notNull(caseSensitive) ? '' : 'i';
       let g = dart.notNull(global) ? 'g' : '';
       let regexp = (function() {
         try {
           return new RegExp(source, m + i + g);
         } catch (e) {
           return e;
         }
 
       })();
-      if (regexp instanceof RegExp)
+      if (dart.notNull(dart.as(regexp instanceof RegExp, core.bool)))
         return regexp;
-      let errorMessage = String(regexp);
+      let errorMessage = dart.as(String(regexp), core.String);
       dart.throw(new core.FormatException(`Illegal RegExp pattern: ${source}, ${errorMessage}`));
     }
     firstMatch(string) {
-      let m = dart.as(this[_nativeRegExp].exec(checkString(string)), core.List$(core.String));
+      let m = dart.as(this[_nativeRegExp].exec(dart.dcall(checkString, string)), core.List$(core.String));
       if (m == null)
         return null;
       return new _MatchImplementation(this, m);
     }
     hasMatch(string) {
-      return this[_nativeRegExp].test(checkString(string));
+      return dart.as(this[_nativeRegExp].test(dart.dcall(checkString, string)), core.bool);
     }
     stringMatch(string) {
-      let match = this.firstMatch(string);
+      let match = dart.dcall(this.firstMatch, string);
       if (match != null)
-        return match.group(0);
+        return dart.as(dart.dsend(match, 'group', 0), core.String);
       return null;
     }
     allMatches(string, start) {
       if (start === void 0)
         start = 0;
-      checkString(string);
-      checkInt(start);
+      dart.dcall(checkString, string);
+      dart.dcall(checkInt, start);
       if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(string[dartx.length])) {
         dart.throw(new core.RangeError.range(start, 0, string[dartx.length]));
       }
       return new _AllMatchesIterable(this, string, start);
     }
     [_execGlobal](string, start) {
       let regexp = this[_nativeGlobalVersion];
       regexp.lastIndex = start;
       let match = dart.as(regexp.exec(string), core.List);
       if (match == null)
@@ skipping 10 matching lines @@
         return null;
       match[dartx.length] = dart.notNull(match[dartx.length]) - 1;
       return new _MatchImplementation(this, dart.as(match, core.List$(core.String)));
     }
     matchAsPrefix(string, start) {
       if (start === void 0)
         start = 0;
       if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(string[dartx.length])) {
         dart.throw(new core.RangeError.range(start, 0, string[dartx.length]));
       }
-      return this[_execAnchored](string, start);
+      return dart.dcall(this[_execAnchored], string, start);
     }
     get isMultiLine() {
       return this[_isMultiLine];
     }
     get isCaseSensitive() {
       return this[_isCaseSensitive];
     }
   }
   JSSyntaxRegExp[dart.implements] = () => [core.RegExp];
   dart.setSignature(JSSyntaxRegExp, {
@@ skipping 13 matching lines @@
   dart.defineExtensionMembers(JSSyntaxRegExp, ['allMatches', 'matchAsPrefix']);
   let _match = Symbol('_match');
   class _MatchImplementation extends core.Object {
     _MatchImplementation(pattern, match) {
       this.pattern = pattern;
       this[_match] = match;
       dart.assert(typeof this[_match].input == 'string');
       dart.assert(typeof this[_match].index == 'number');
     }
     get input() {
-      return this[_match].input;
+      return dart.as(this[_match].input, core.String);
     }
     get start() {
-      return this[_match].index;
+      return dart.as(this[_match].index, core.int);
     }
     get end() {
       return dart.notNull(this.start) + dart.notNull(this[_match][dartx.get](0)[dartx.length]);
     }
     group(index) {
       return this[_match][dartx.get](index);
     }
     get(index) {
-      return this.group(index);
+      return dart.dcall(this.group, index);
     }
     get groupCount() {
       return dart.notNull(this[_match][dartx.length]) - 1;
     }
     groups(groups) {
       let out = dart.list([], core.String);
       for (let i of groups) {
-        out[dartx.add](this.group(i));
+        dart.dcall(out[dartx.add], dart.dcall(this.group, i));
       }
       return out;
     }
   }
   _MatchImplementation[dart.implements] = () => [core.Match];
   dart.setSignature(_MatchImplementation, {
     constructors: () => ({_MatchImplementation: [_MatchImplementation, [core.Pattern, core.List$(core.String)]]}),
     methods: () => ({
       group: [core.String, [core.int]],
       get: [core.String, [core.int]],
@@ skipping 28 matching lines @@
       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][dartx.length])) {
-        let match = this[_regExp][_execGlobal](this[_string], this[_nextIndex]);
+        let match = dart.dcall(this[_regExp][_execGlobal], this[_string], this[_nextIndex]);
         if (match != null) {
-          this[_current] = match;
-          let nextIndex = match.end;
-          if (match.start == nextIndex) {
+          this[_current] = dart.as(match, core.Match);
+          let nextIndex = dart.as(dart.dload(match, 'end'), core.int);
+          if (dart.equals(dart.dload(match, 'start'), nextIndex)) {
             nextIndex = dart.notNull(nextIndex) + 1;
           }
           this[_nextIndex] = nextIndex;
           return true;
         }
       }
       this[_current] = null;
       this[_string] = null;
       return false;
     }
   }
   _AllMatchesIterator[dart.implements] = () => [core.Iterator$(core.Match)];
   dart.setSignature(_AllMatchesIterator, {
     constructors: () => ({_AllMatchesIterator: [_AllMatchesIterator, [JSSyntaxRegExp, core.String, core.int]]}),
     methods: () => ({moveNext: [core.bool, []]})
   });
   function firstMatchAfter(regExp, string, start) {
-    return regExp[_execGlobal](string, start);
+    return dart.dcall(regExp[_execGlobal], string, start);
   }
   dart.fn(firstMatchAfter, core.Match, [JSSyntaxRegExp, core.String, core.int]);
   class StringMatch extends core.Object {
     StringMatch(start, input, pattern) {
       this.start = start;
       this.input = input;
       this.pattern = pattern;
     }
     get end() {
       return dart.notNull(this.start) + dart.notNull(this.pattern[dartx.length]);
     }
     get(g) {
-      return this.group(g);
+      return dart.dcall(this.group, g);
     }
     get groupCount() {
       return 0;
     }
     group(group_) {
       if (group_ != 0) {
         dart.throw(new core.RangeError.value(group_));
       }
       return this.pattern;
     }
     groups(groups_) {
       let result = core.List$(core.String).new();
       for (let g of groups_) {
-        result[dartx.add](this.group(g));
+        dart.dcall(result[dartx.add], dart.dcall(this.group, g));
       }
       return result;
     }
   }
   StringMatch[dart.implements] = () => [core.Match];
   dart.setSignature(StringMatch, {
     constructors: () => ({StringMatch: [StringMatch, [core.int, core.String, core.String]]}),
     methods: () => ({
       get: [core.String, [core.int]],
       group: [core.String, [core.int]],
       groups: [core.List$(core.String), [core.List$(core.int)]]
     })
   });
   function allMatchesInStringUnchecked(needle, haystack, startIndex) {
     let result = core.List$(core.Match).new();
     let length = haystack[dartx.length];
     let patternLength = needle[dartx.length];
     while (true) {
-      let position = haystack[dartx.indexOf](needle, startIndex);
+      let position = dart.dcall(haystack[dartx.indexOf], needle, startIndex);
       if (position == -1) {
         break;
       }
-      result[dartx.add](new StringMatch(position, haystack, needle));
+      dart.dcall(result[dartx.add], new StringMatch(position, haystack, needle));
       let endIndex = dart.notNull(position) + dart.notNull(patternLength);
       if (endIndex == length) {
         break;
       } else if (position == endIndex) {
         startIndex = dart.notNull(startIndex) + 1;
       } else {
         startIndex = endIndex;
       }
     }
     return result;
@@ skipping 19 matching lines @@
     let match = dart.dsend(regexp, _execGlobal, receiver, startIndex);
     if (match == null)
       return receiver;
     let start = dart.dload(match, 'start');
     let end = dart.dload(match, 'end');
     return `${dart.dsend(receiver, 'substring', 0, start)}${to}${dart.dsend(receiver, 'substring', end)}`;
   }
   dart.fn(stringReplaceFirstRE);
   let ESCAPE_REGEXP = '[[\\]{}()*+?.\\\\^$|]';
   function stringReplaceAllUnchecked(receiver, from, to) {
-    checkString(to);
+    dart.dcall(checkString, to);
     if (typeof from == 'string') {
       if (dart.equals(from, "")) {
         if (dart.equals(receiver, "")) {
           return to;
         } else {
           let result = new core.StringBuffer();
           let length = dart.as(dart.dload(receiver, 'length'), core.int);
-          result.write(to);
+          dart.dcall(result.write, to);
           for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-            result.write(dart.dindex(receiver, i));
-            result.write(to);
+            dart.dcall(result.write, dart.dindex(receiver, i));
+            dart.dcall(result.write, to);
           }
-          return dart.toString(result);
+          return dart.dcall(result.toString);
         }
       } else {
         let quoter = new RegExp(ESCAPE_REGEXP, 'g');
         let quoted = from.replace(quoter, "\\$&");
         let replacer = new RegExp(quoted, 'g');
-        return stringReplaceJS(receiver, replacer, to);
+        return dart.dcall(stringReplaceJS, receiver, replacer, to);
       }
     } else if (dart.is(from, JSSyntaxRegExp)) {
-      let re = regExpGetGlobalNative(dart.as(from, JSSyntaxRegExp));
-      return stringReplaceJS(receiver, re, to);
+      let re = dart.dcall(regExpGetGlobalNative, from);
+      return dart.dcall(stringReplaceJS, receiver, re, to);
     } else {
-      checkNull(from);
+      dart.dcall(checkNull, from);
       dart.throw("String.replaceAll(Pattern) UNIMPLEMENTED");
     }
   }
   dart.fn(stringReplaceAllUnchecked);
   function _matchString(match) {
     return match.get(0);
   }
   dart.fn(_matchString, core.String, [core.Match]);
   function _stringIdentity(string) {
     return string;
   }
   dart.fn(_stringIdentity, core.String, [core.String]);
   function stringReplaceAllFuncUnchecked(receiver, pattern, onMatch, onNonMatch) {
     if (!dart.is(pattern, core.Pattern)) {
       dart.throw(new core.ArgumentError(`${pattern} is not a Pattern`));
     }
     if (onMatch == null)
       onMatch = _matchString;
     if (onNonMatch == null)
       onNonMatch = _stringIdentity;
     if (typeof pattern == 'string') {
-      return stringReplaceAllStringFuncUnchecked(receiver, pattern, onMatch, onNonMatch);
+      return dart.dcall(stringReplaceAllStringFuncUnchecked, receiver, pattern, onMatch, onNonMatch);
     }
     let buffer = new core.StringBuffer();
     let startIndex = 0;
     for (let match of dart.as(dart.dsend(pattern, 'allMatches', receiver), core.Iterable$(core.Match))) {
-      buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex, match.start)));
-      buffer.write(dart.dcall(onMatch, match));
+      dart.dcall(buffer.write, dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex, match.start)));
+      dart.dcall(buffer.write, dart.dcall(onMatch, match));
       startIndex = match.end;
     }
-    buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex)));
-    return dart.toString(buffer);
+    dart.dcall(buffer.write, dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex)));
+    return dart.dcall(buffer.toString);
   }
   dart.fn(stringReplaceAllFuncUnchecked);
   function stringReplaceAllEmptyFuncUnchecked(receiver, onMatch, onNonMatch) {
     let buffer = new core.StringBuffer();
     let length = dart.as(dart.dload(receiver, 'length'), core.int);
     let i = 0;
-    buffer.write(dart.dcall(onNonMatch, ""));
+    dart.dcall(buffer.write, dart.dcall(onNonMatch, ""));
     while (dart.notNull(i) < dart.notNull(length)) {
-      buffer.write(dart.dcall(onMatch, new StringMatch(i, dart.as(receiver, core.String), "")));
+      dart.dcall(buffer.write, dart.dcall(onMatch, new StringMatch(i, dart.as(receiver, core.String), "")));
       let code = dart.as(dart.dsend(receiver, 'codeUnitAt', i), core.int);
       if ((dart.notNull(code) & ~1023) == 55296 && dart.notNull(length) > dart.notNull(i) + 1) {
         code = dart.as(dart.dsend(receiver, 'codeUnitAt', dart.notNull(i) + 1), core.int);
         if ((dart.notNull(code) & ~1023) == 56320) {
-          buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', i, dart.notNull(i) + 2)));
+          dart.dcall(buffer.write, dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', i, dart.notNull(i) + 2)));
           i = dart.notNull(i) + 2;
           continue;
         }
       }
-      buffer.write(dart.dcall(onNonMatch, dart.dindex(receiver, i)));
+      dart.dcall(buffer.write, dart.dcall(onNonMatch, dart.dindex(receiver, i)));
       i = dart.notNull(i) + 1;
     }
-    buffer.write(dart.dcall(onMatch, new StringMatch(i, dart.as(receiver, core.String), "")));
-    buffer.write(dart.dcall(onNonMatch, ""));
-    return dart.toString(buffer);
+    dart.dcall(buffer.write, dart.dcall(onMatch, new StringMatch(i, dart.as(receiver, core.String), "")));
+    dart.dcall(buffer.write, dart.dcall(onNonMatch, ""));
+    return dart.dcall(buffer.toString);
   }
   dart.fn(stringReplaceAllEmptyFuncUnchecked);
   function stringReplaceAllStringFuncUnchecked(receiver, pattern, onMatch, onNonMatch) {
     let patternLength = dart.as(dart.dload(pattern, 'length'), core.int);
     if (patternLength == 0) {
-      return stringReplaceAllEmptyFuncUnchecked(receiver, onMatch, onNonMatch);
+      return dart.dcall(stringReplaceAllEmptyFuncUnchecked, receiver, onMatch, onNonMatch);
     }
     let length = dart.as(dart.dload(receiver, 'length'), core.int);
     let buffer = new core.StringBuffer();
     let startIndex = 0;
     while (dart.notNull(startIndex) < dart.notNull(length)) {
       let position = dart.as(dart.dsend(receiver, 'indexOf', pattern, startIndex), core.int);
       if (position == -1) {
         break;
       }
-      buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex, position)));
-      buffer.write(dart.dcall(onMatch, new StringMatch(position, dart.as(receiver, core.String), dart.as(pattern, core.String))));
+      dart.dcall(buffer.write, dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex, position)));
+      dart.dcall(buffer.write, dart.dcall(onMatch, new StringMatch(position, dart.as(receiver, core.String), dart.as(pattern, core.String))));
       startIndex = dart.notNull(position) + dart.notNull(patternLength);
     }
-    buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex)));
-    return dart.toString(buffer);
+    dart.dcall(buffer.write, dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex)));
+    return dart.dcall(buffer.toString);
   }
   dart.fn(stringReplaceAllStringFuncUnchecked);
   function stringReplaceFirstUnchecked(receiver, from, to, startIndex) {
     if (startIndex === void 0)
       startIndex = 0;
     if (typeof from == 'string') {
       let index = dart.dsend(receiver, 'indexOf', from, startIndex);
       if (dart.notNull(dart.as(dart.dsend(index, '<', 0), core.bool)))
         return receiver;
       return `${dart.dsend(receiver, 'substring', 0, index)}${to}` + `${dart.dsend(receiver, 'substring', dart.dsend(index, '+', dart.dload(from, 'length')))}`;
     } else if (dart.is(from, JSSyntaxRegExp)) {
-      return startIndex == 0 ? stringReplaceJS(receiver, regExpGetNative(dart.as(from, JSSyntaxRegExp)), to) : stringReplaceFirstRE(receiver, from, to, startIndex);
+      return startIndex == 0 ? dart.dcall(stringReplaceJS, receiver, dart.dcall(regExpGetNative, from), to) : dart.dcall(stringReplaceFirstRE, receiver, from, to, startIndex);
     } else {
-      checkNull(from);
+      dart.dcall(checkNull, from);
       dart.throw("String.replace(Pattern) UNIMPLEMENTED");
     }
   }
   dart.fn(stringReplaceFirstUnchecked, dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic], [core.int]);
   function stringJoinUnchecked(array, separator) {
     return array.join(separator);
   }
   dart.fn(stringJoinUnchecked);
   function getRuntimeType(object) {
     return dart.as(dart.realRuntimeType(object), core.Type);
   }
   dart.fn(getRuntimeType, core.Type, [dart.dynamic]);
   function getIndex(array, index) {
-    dart.assert(isJsArray(array));
+    dart.assert(dart.dcall(isJsArray, array));
     return array[index];
   }
   dart.fn(getIndex, dart.dynamic, [dart.dynamic, core.int]);
   function getLength(array) {
-    dart.assert(isJsArray(array));
-    return array.length;
+    dart.assert(dart.dcall(isJsArray, array));
+    return dart.as(array.length, core.int);
   }
   dart.fn(getLength, core.int, [dart.dynamic]);
   function isJsArray(value) {
     return dart.is(value, _interceptors.JSArray);
   }
   dart.fn(isJsArray, core.bool, [dart.dynamic]);
   class _Patch extends core.Object {
     _Patch() {
     }
   }
   dart.setSignature(_Patch, {
     constructors: () => ({_Patch: [_Patch, []]})
   });
   let patch = dart.const(new _Patch());
   class InternalMap extends core.Object {}
   class Primitives extends core.Object {
     static initializeStatics(id) {
       Primitives.mirrorFunctionCacheName = dart.notNull(Primitives.mirrorFunctionCacheName) + `_${id}`;
       Primitives.mirrorInvokeCacheName = dart.notNull(Primitives.mirrorInvokeCacheName) + `_${id}`;
     }
     static objectHashCode(object) {
       let hash = dart.as(object.$identityHash, core.int);
       if (hash == null) {
-        hash = Math.random() * 0x3fffffff | 0;
+        hash = dart.as(Math.random() * 0x3fffffff | 0, core.int);
         object.$identityHash = hash;
       }
-      return hash;
+      return dart.as(hash, core.int);
     }
     static _throwFormatException(string) {
       dart.throw(new core.FormatException(string));
     }
     static parseInt(source, radix, handleError) {
       if (handleError == null)
-        handleError = dart.fn(s => dart.as(Primitives._throwFormatException(dart.as(s, core.String)), core.int), core.int, [dart.dynamic]);
-      checkString(source);
+        handleError = dart.fn(s => dart.as(dart.dcall(Primitives._throwFormatException, s), core.int), core.int, [dart.dynamic]);
+      dart.dcall(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;
       let nonDecimalHexIndex = 4;
       if (radix == null) {
         radix = 10;
         if (match != null) {
           if (dart.dindex(match, hexIndex) != null) {
-            return parseInt(source, 16);
+            return dart.as(parseInt(source, 16), core.int);
           }
           if (dart.dindex(match, decimalIndex) != null) {
-            return parseInt(source, 10);
+            return dart.as(parseInt(source, 10), core.int);
           }
           return handleError(source);
         }
       } else {
         if (!(typeof radix == 'number'))
           dart.throw(new core.ArgumentError("Radix is not an integer"));
         if (dart.notNull(radix) < 2 || dart.notNull(radix) > 36) {
           dart.throw(new core.RangeError(`Radix ${radix} not in range 2..36`));
         }
         if (match != null) {
           if (radix == 10 && dart.dindex(match, decimalIndex) != null) {
-            return parseInt(source, 10);
+            return dart.as(parseInt(source, 10), core.int);
           }
           if (dart.notNull(radix) < 10 || dart.dindex(match, decimalIndex) == null) {
             let maxCharCode = null;
             if (dart.notNull(radix) <= 10) {
               maxCharCode = 48 + dart.notNull(radix) - 1;
             } else {
               maxCharCode = 97 + dart.notNull(radix) - 10 - 1;
             }
             let digitsPart = dart.as(dart.dindex(match, digitsIndex), core.String);
             for (let i = 0; dart.notNull(i) < dart.notNull(digitsPart[dartx.length]); i = dart.notNull(i) + 1) {
-              let characterCode = dart.notNull(digitsPart[dartx.codeUnitAt](0)) | 32;
-              if (dart.notNull(digitsPart[dartx.codeUnitAt](i)) > dart.notNull(maxCharCode)) {
+              let characterCode = dart.notNull(dart.dcall(digitsPart[dartx.codeUnitAt], 0)) | 32;
+              if (dart.notNull(dart.dcall(digitsPart[dartx.codeUnitAt], i)) > dart.notNull(maxCharCode)) {
                 return handleError(source);
               }
             }
           }
         }
       }
       if (match == null)
         return handleError(source);
-      return parseInt(source, radix);
+      return dart.as(parseInt(source, radix), core.int);
     }
     static parseDouble(source, handleError) {
-      checkString(source);
+      dart.dcall(checkString, source);
       if (handleError == null)
-        handleError = dart.fn(s => dart.as(Primitives._throwFormatException(dart.as(s, core.String)), core.double), core.double, [dart.dynamic]);
-      if (!/^\s*[+-]?(?:Infinity|NaN|(?:\.\d+|\d+(?:\.\d*)?)(?:[eE][+-]?\d+)?)\s*$/.test(source)) {
+        handleError = dart.fn(s => dart.as(dart.dcall(Primitives._throwFormatException, s), core.double), core.double, [dart.dynamic]);
+      if (!dart.notNull(dart.as(/^\s*[+-]?(?:Infinity|NaN|(?:\.\d+|\d+(?:\.\d*)?)(?:[eE][+-]?\d+)?)\s*$/.test(source), core.bool))) {
         return handleError(source);
       }
       let result = parseFloat(source);
-      if (dart.notNull(result[dartx.isNaN])) {
-        let trimmed = source[dartx.trim]();
-        if (trimmed == 'NaN' || trimmed == '+NaN' || trimmed == '-NaN') {
-          return result;
+      if (dart.notNull(dart.as(dart.dload(result, 'isNaN'), core.bool))) {
+        let trimmed = dart.dcall(source[dartx.trim]);
+        if (dart.equals(trimmed, 'NaN') || dart.equals(trimmed, '+NaN') || dart.equals(trimmed, '-NaN')) {
+          return dart.as(result, core.double);
         }
         return handleError(source);
       }
-      return result;
+      return dart.as(result, core.double);
     }
     static objectTypeName(object) {
-      return dart.toString(getRuntimeType(object));
+      return dart.dcall(dart.dcall(getRuntimeType, object).toString);
     }
     static objectToString(object) {
-      let name = dart.typeName(dart.realRuntimeType(object));
+      let name = dart.as(dart.typeName(dart.realRuntimeType(object)), core.String);
       return `Instance of '${name}'`;
     }
     static dateNow() {
-      return Date.now();
+      return dart.as(Date.now(), core.num);
     }
     static initTicker() {
       if (Primitives.timerFrequency != null)
         return;
       Primitives.timerFrequency = 1000;
       Primitives.timerTicks = Primitives.dateNow;
-      if (typeof window == "undefined")
+      if (dart.notNull(dart.as(typeof window == "undefined", core.bool)))
         return;
       let jsWindow = window;
       if (jsWindow == null)
         return;
       let performance = jsWindow.performance;
       if (performance == null)
         return;
-      if (typeof performance.now != "function")
+      if (dart.notNull(dart.as(typeof performance.now != "function", core.bool)))
         return;
       Primitives.timerFrequency = 1000000;
-      Primitives.timerTicks = dart.fn(() => (1000 * performance.now())[dartx.floor](), core.int, []);
+      Primitives.timerTicks = dart.fn(() => dart.dcall((1000 * dart.notNull(dart.as(performance.now(), core.num)))[dartx.floor]), core.int, []);
     }
     static get isD8() {
-      return typeof version == "function" && typeof os == "object" && "system" in os;
+      return dart.as(typeof version == "function" && typeof os == "object" && "system" in os, core.bool);
     }
     static get isJsshell() {
-      return typeof version == "function" && typeof system == "function";
+      return dart.as(typeof version == "function" && typeof system == "function", core.bool);
     }
     static currentUri() {
-      if (!!self.location) {
-        return self.location.href;
+      if (dart.notNull(dart.as(!!self.location, core.bool))) {
+        return dart.as(self.location.href, core.String);
       }
       return null;
     }
     static _fromCharCodeApply(array) {
       let result = "";
       let kMaxApply = 500;
       let end = array[dartx.length];
-      for (let i = 0; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + dart.notNull(kMaxApply)) {
+      for (let i = 0; dart.notNull(dart.as(dart.dsend(i, '<', end), core.bool)); i = dart.dsend(i, '+', kMaxApply)) {
         let subarray = null;
-        if (dart.notNull(end) <= dart.notNull(kMaxApply)) {
+        if (dart.notNull(end) <= dart.notNull(dart.as(kMaxApply, core.num))) {
           subarray = array;
         } else {
-          subarray = array.slice(i, dart.notNull(i) + dart.notNull(kMaxApply) < dart.notNull(end) ? dart.notNull(i) + dart.notNull(kMaxApply) : end);
+          subarray = array.slice(i, dart.notNull(dart.as(dart.dsend(dart.dsend(i, '+', kMaxApply), '<', end), core.bool)) ? dart.dsend(i, '+', kMaxApply) : end);
         }
-        result = result + String.fromCharCode.apply(null, subarray);
+        result = dart.as(result + String.fromCharCode.apply(null, subarray), core.String);
       }
       return result;
     }
     static stringFromCodePoints(codePoints) {
       let a = dart.list([], core.int);
       for (let i of dart.as(codePoints, core.Iterable)) {
         if (!(typeof i == 'number'))
           dart.throw(new core.ArgumentError(i));
         if (dart.notNull(dart.as(dart.dsend(i, '<=', 65535), core.bool))) {
-          a[dartx.add](dart.as(i, core.int));
+          dart.dcall(a[dartx.add], i);
         } else if (dart.notNull(dart.as(dart.dsend(i, '<=', 1114111), core.bool))) {
-          a[dartx.add]((55296)[dartx['+']](dart.as(dart.dsend(dart.dsend(dart.dsend(i, '-', 65536), '>>', 10), '&', 1023), core.num)));
-          a[dartx.add]((56320)[dartx['+']](dart.as(dart.dsend(i, '&', 1023), core.num)));
+          dart.dcall(a[dartx.add], (55296)[dartx['+']](dart.as(dart.dsend(dart.dsend(dart.dsend(i, '-', 65536), '>>', 10), '&', 1023), core.num)));
+          dart.dcall(a[dartx.add], (56320)[dartx['+']](dart.as(dart.dsend(i, '&', 1023), core.num)));
         } else {
           dart.throw(new core.ArgumentError(i));
         }
       }
-      return Primitives._fromCharCodeApply(a);
+      return dart.dcall(Primitives._fromCharCodeApply, a);
     }
     static stringFromCharCodes(charCodes) {
       for (let i of dart.as(charCodes, core.Iterable)) {
         if (!(typeof i == 'number'))
           dart.throw(new core.ArgumentError(i));
         if (dart.notNull(dart.as(dart.dsend(i, '<', 0), core.bool)))
           dart.throw(new core.ArgumentError(i));
         if (dart.notNull(dart.as(dart.dsend(i, '>', 65535), core.bool)))
-          return Primitives.stringFromCodePoints(charCodes);
+          return dart.dcall(Primitives.stringFromCodePoints, charCodes);
       }
-      return Primitives._fromCharCodeApply(dart.as(charCodes, core.List$(core.int)));
+      return dart.dcall(Primitives._fromCharCodeApply, charCodes);
     }
     static stringFromCharCode(charCode) {
       if (0 <= dart.notNull(dart.as(charCode, core.num))) {
         if (dart.notNull(dart.as(dart.dsend(charCode, '<=', 65535), core.bool))) {
-          return String.fromCharCode(charCode);
+          return dart.as(String.fromCharCode(charCode), core.String);
         }
         if (dart.notNull(dart.as(dart.dsend(charCode, '<=', 1114111), core.bool))) {
           let bits = dart.dsend(charCode, '-', 65536);
           let low = (56320)[dartx['|']](dart.as(dart.dsend(bits, '&', 1023), core.int));
           let high = (55296)[dartx['|']](dart.as(dart.dsend(bits, '>>', 10), core.int));
-          return String.fromCharCode(high, low);
+          return dart.as(String.fromCharCode(high, low), core.String);
         }
       }
       dart.throw(new core.RangeError.range(dart.as(charCode, core.num), 0, 1114111));
     }
     static stringConcatUnchecked(string1, string2) {
-      return _foreign_helper.JS_STRING_CONCAT(string1, string2);
+      return dart.dcall(_foreign_helper.JS_STRING_CONCAT, string1, string2);
     }
     static flattenString(str) {
-      return str.charCodeAt(0) == 0 ? str : str;
+      return dart.as(str.charCodeAt(0) == 0 ? str : str, core.String);
     }
     static getTimeZoneName(receiver) {
-      let d = Primitives.lazyAsJsDate(receiver);
+      let d = dart.dcall(Primitives.lazyAsJsDate, receiver);
       let match = dart.as(/\((.*)\)/.exec(d.toString()), core.List);
       if (match != null)
         return dart.as(match[dartx.get](1), core.String);
       match = dart.as(/^[A-Z,a-z]{3}\s[A-Z,a-z]{3}\s\d+\s\d{2}:\d{2}:\d{2}\s([A-Z]{3,5})\s\d{4}$/.exec(d.toString()), core.List);
       if (match != null)
         return dart.as(match[dartx.get](1), core.String);
       match = dart.as(/(?:GMT|UTC)[+-]\d{4}/.exec(d.toString()), core.List);
       if (match != null)
         return dart.as(match[dartx.get](0), core.String);
       return "";
     }
     static getTimeZoneOffsetInMinutes(receiver) {
-      return -Primitives.lazyAsJsDate(receiver).getTimezoneOffset();
+      return dart.as(dart.dsend(dart.dcall(Primitives.lazyAsJsDate, receiver).getTimezoneOffset(), 'unary-'), core.int);
     }
     static valueFromDecomposedDate(years, month, day, hours, minutes, seconds, milliseconds, isUtc) {
       let MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
-      checkInt(years);
-      checkInt(month);
-      checkInt(day);
-      checkInt(hours);
-      checkInt(minutes);
-      checkInt(seconds);
-      checkInt(milliseconds);
-      checkBool(isUtc);
+      dart.dcall(checkInt, years);
+      dart.dcall(checkInt, month);
+      dart.dcall(checkInt, day);
+      dart.dcall(checkInt, hours);
+      dart.dcall(checkInt, minutes);
+      dart.dcall(checkInt, seconds);
+      dart.dcall(checkInt, milliseconds);
+      dart.dcall(checkBool, isUtc);
       let jsMonth = dart.dsend(month, '-', 1);
       let value = null;
       if (dart.notNull(dart.as(isUtc, core.bool))) {
         value = Date.UTC(years, jsMonth, day, hours, minutes, seconds, milliseconds);
       } else {
         value = new Date(years, jsMonth, day, hours, minutes, seconds, milliseconds).valueOf();
       }
       if (dart.notNull(dart.as(dart.dload(value, 'isNaN'), core.bool)) || dart.notNull(dart.as(dart.dsend(value, '<', -dart.notNull(MAX_MILLISECONDS_SINCE_EPOCH)), core.bool)) || dart.notNull(dart.as(dart.dsend(value, '>', MAX_MILLISECONDS_SINCE_EPOCH), core.bool))) {
         return null;
       }
       if (dart.notNull(dart.as(dart.dsend(years, '<=', 0), core.bool)) || dart.notNull(dart.as(dart.dsend(years, '<', 100), core.bool)))
-        return Primitives.patchUpY2K(value, years, isUtc);
+        return dart.dcall(Primitives.patchUpY2K, value, years, isUtc);
       return value;
     }
     static patchUpY2K(value, years, isUtc) {
       let date = new Date(value);
       if (dart.notNull(dart.as(isUtc, core.bool))) {
         date.setUTCFullYear(years);
       } else {
         date.setFullYear(years);
       }
       return date.valueOf();
     }
     static lazyAsJsDate(receiver) {
-      if (receiver.date === void 0) {
+      if (dart.notNull(dart.as(receiver.date === void 0, core.bool))) {
         receiver.date = new Date(dart.dload(receiver, 'millisecondsSinceEpoch'));
       }
       return receiver.date;
     }
     static getYear(receiver) {
-      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? Primitives.lazyAsJsDate(receiver).getUTCFullYear() + 0 : Primitives.lazyAsJsDate(receiver).getFullYear() + 0;
+      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? dart.dcall(Primitives.lazyAsJsDate, receiver).getUTCFullYear() + 0 : dart.dcall(Primitives.lazyAsJsDate, receiver).getFullYear() + 0;
     }
     static getMonth(receiver) {
-      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? Primitives.lazyAsJsDate(receiver).getUTCMonth() + 1 : Primitives.lazyAsJsDate(receiver).getMonth() + 1;
+      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? dart.dcall(Primitives.lazyAsJsDate, receiver).getUTCMonth() + 1 : dart.dcall(Primitives.lazyAsJsDate, receiver).getMonth() + 1;
     }
     static getDay(receiver) {
-      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? Primitives.lazyAsJsDate(receiver).getUTCDate() + 0 : Primitives.lazyAsJsDate(receiver).getDate() + 0;
+      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? dart.dcall(Primitives.lazyAsJsDate, receiver).getUTCDate() + 0 : dart.dcall(Primitives.lazyAsJsDate, receiver).getDate() + 0;
     }
     static getHours(receiver) {
-      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? Primitives.lazyAsJsDate(receiver).getUTCHours() + 0 : Primitives.lazyAsJsDate(receiver).getHours() + 0;
+      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? dart.dcall(Primitives.lazyAsJsDate, receiver).getUTCHours() + 0 : dart.dcall(Primitives.lazyAsJsDate, receiver).getHours() + 0;
     }
     static getMinutes(receiver) {
-      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? Primitives.lazyAsJsDate(receiver).getUTCMinutes() + 0 : Primitives.lazyAsJsDate(receiver).getMinutes() + 0;
+      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? dart.dcall(Primitives.lazyAsJsDate, receiver).getUTCMinutes() + 0 : dart.dcall(Primitives.lazyAsJsDate, receiver).getMinutes() + 0;
     }
     static getSeconds(receiver) {
-      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? Primitives.lazyAsJsDate(receiver).getUTCSeconds() + 0 : Primitives.lazyAsJsDate(receiver).getSeconds() + 0;
+      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? dart.dcall(Primitives.lazyAsJsDate, receiver).getUTCSeconds() + 0 : dart.dcall(Primitives.lazyAsJsDate, receiver).getSeconds() + 0;
     }
     static getMilliseconds(receiver) {
-      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? Primitives.lazyAsJsDate(receiver).getUTCMilliseconds() + 0 : Primitives.lazyAsJsDate(receiver).getMilliseconds() + 0;
+      return dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? dart.dcall(Primitives.lazyAsJsDate, receiver).getUTCMilliseconds() + 0 : dart.dcall(Primitives.lazyAsJsDate, receiver).getMilliseconds() + 0;
     }
     static getWeekday(receiver) {
-      let weekday = dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? Primitives.lazyAsJsDate(receiver).getUTCDay() + 0 : Primitives.lazyAsJsDate(receiver).getDay() + 0;
+      let weekday = dart.notNull(dart.as(dart.dload(receiver, 'isUtc'), core.bool)) ? dart.as(dart.dcall(Primitives.lazyAsJsDate, receiver).getUTCDay() + 0, core.int) : dart.as(dart.dcall(Primitives.lazyAsJsDate, receiver).getDay() + 0, core.int);
       return (dart.notNull(weekday) + 6) % 7 + 1;
     }
     static valueFromDateString(str) {
       if (!(typeof str == 'string'))
         dart.throw(new core.ArgumentError(str));
       let value = Date.parse(str);
-      if (dart.notNull(value[dartx.isNaN]))
+      if (dart.notNull(dart.as(dart.dload(value, 'isNaN'), core.bool)))
         dart.throw(new core.ArgumentError(str));
       return value;
     }
     static getProperty(object, key) {
       if (object == null || typeof object == 'boolean' || dart.is(object, core.num) || typeof object == 'string') {
         dart.throw(new core.ArgumentError(object));
       }
       return object[key];
     }
     static setProperty(object, key, value) {
       if (object == null || typeof object == 'boolean' || dart.is(object, core.num) || typeof object == 'string') {
         dart.throw(new core.ArgumentError(object));
       }
       object[key] = value;
     }
     static identicalImplementation(a, b) {
-      return a == null ? b == null : a === b;
+      return dart.notNull(dart.as(a == null, core.bool)) ? dart.as(b == null, core.bool) : dart.as(a === b, core.bool);
     }
     static extractStackTrace(error) {
-      return getTraceFromException(error.$thrownJsError);
+      return dart.dcall(getTraceFromException, error.$thrownJsError);
     }
   }
   dart.setSignature(Primitives, {
     statics: () => ({
       initializeStatics: [dart.void, [core.int]],
       objectHashCode: [core.int, [dart.dynamic]],
       _throwFormatException: [dart.dynamic, [core.String]],
       parseInt: [core.int, [core.String, core.int, dart.functionType(core.int, [core.String])]],
       parseDouble: [core.double, [core.String, dart.functionType(core.double, [core.String])]],
       objectTypeName: [core.String, [core.Object]],
@@ skipping 138 matching lines @@
   let _trace = Symbol('_trace');
   class _StackTrace extends core.Object {
     _StackTrace(exception) {
       this[_exception] = exception;
       this[_trace] = null;
     }
     toString() {
       if (this[_trace] != null)
         return this[_trace];
       let trace = null;
-      if (typeof this[_exception] === "object") {
+      if (dart.notNull(dart.as(typeof this[_exception] === "object", core.bool))) {
         trace = dart.as(this[_exception].stack, core.String);
       }
       return this[_trace] = trace == null ? '' : trace;
     }
   }
   _StackTrace[dart.implements] = () => [core.StackTrace];
   dart.setSignature(_StackTrace, {
     constructors: () => ({_StackTrace: [_StackTrace, [dart.dynamic]]})
   });
   function objectHashCode(object) {
-    if (object == null || typeof object != 'object') {
-      return dart.hashCode(object);
+    if (object == null || dart.notNull(dart.as(typeof object != 'object', core.bool))) {
+      return dart.as(dart.dload(object, 'hashCode'), core.int);
     } else {
-      return Primitives.objectHashCode(object);
+      return dart.dcall(Primitives.objectHashCode, object);
     }
   }
   dart.fn(objectHashCode, core.int, [dart.dynamic]);
   function fillLiteralMap(keyValuePairs, result) {
     let index = 0;
-    let length = getLength(keyValuePairs);
+    let length = dart.dcall(getLength, keyValuePairs);
     while (dart.notNull(index) < dart.notNull(length)) {
-      let key = getIndex(keyValuePairs, (() => {
+      let key = dart.dcall(getIndex, keyValuePairs, (() => {
         let x = index;
         index = dart.notNull(x) + 1;
         return x;
       })());
-      let value = getIndex(keyValuePairs, (() => {
+      let value = dart.dcall(getIndex, keyValuePairs, (() => {
         let x = index;
         index = dart.notNull(x) + 1;
         return x;
       })());
       result.set(key, value);
     }
     return result;
   }
   dart.fn(fillLiteralMap, dart.dynamic, [dart.dynamic, core.Map]);
   function jsHasOwnProperty(jsObject, property) {
-    return jsObject.hasOwnProperty(property);
+    return dart.as(jsObject.hasOwnProperty(property), core.bool);
   }
   dart.fn(jsHasOwnProperty, core.bool, [dart.dynamic, core.String]);
   function jsPropertyAccess(jsObject, property) {
     return jsObject[property];
   }
   dart.fn(jsPropertyAccess, dart.dynamic, [dart.dynamic, core.String]);
   function getFallThroughError() {
     return new FallThroughErrorImplementation();
   }
   dart.fn(getFallThroughError);
@@ skipping 17 matching lines @@
     JSName(name) {
       this.name = name;
     }
   }
   dart.setSignature(JSName, {
     constructors: () => ({JSName: [JSName, [core.String]]})
   });
   class JavaScriptIndexingBehavior extends _interceptors.JSMutableIndexable {}
   class TypeErrorImplementation extends core.Error {
     TypeErrorImplementation(value, type) {
-      this.message = `type '${Primitives.objectTypeName(value)}' is not a subtype ` + `of type '${type}'`;
+      this.message = `type '${dart.dcall(Primitives.objectTypeName, value)}' is not a subtype ` + `of type '${type}'`;
       super.Error();
     }
     fromMessage(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
@@ skipping 35 matching lines @@
       super.Error();
     }
     toString() {
       return `RuntimeError: ${this.message}`;
     }
   }
   dart.setSignature(RuntimeError, {
     constructors: () => ({RuntimeError: [RuntimeError, [dart.dynamic]]})
   });
   function random64() {
-    let int32a = Math.random() * 0x100000000 >>> 0;
-    let int32b = Math.random() * 0x100000000 >>> 0;
+    let int32a = dart.as(Math.random() * 0x100000000 >>> 0, core.int);
+    let int32b = dart.as(Math.random() * 0x100000000 >>> 0, core.int);
     return dart.notNull(int32a) + dart.notNull(int32b) * 4294967296;
   }
   dart.fn(random64, core.int, []);
   function jsonEncodeNative(string) {
-    return JSON.stringify(string);
+    return dart.as(JSON.stringify(string), core.String);
   }
   dart.fn(jsonEncodeNative, core.String, [core.String]);
   let _jsIterator = Symbol('_jsIterator');
   let SyncIterator$ = dart.generic(function(E) {
     class SyncIterator extends core.Object {
       SyncIterator(jsIterator) {
         this[_jsIterator] = jsIterator;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         let ret = this[_jsIterator].next();
         this[_current] = dart.as(ret.value, E);
-        return !ret.done;
+        return dart.as(!ret.done, core.bool);
       }
     }
     SyncIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(SyncIterator, {
       constructors: () => ({SyncIterator: [SyncIterator$(E), [dart.dynamic]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return SyncIterator;
   });
   let SyncIterator = SyncIterator$();
   let _generator = Symbol('_generator');
   let _args = Symbol('_args');
   let SyncIterable$ = dart.generic(function(E) {
     class SyncIterable extends collection.IterableBase$(E) {
       SyncIterable(generator, args) {
         this[_generator] = generator;
         this[_args] = args;
         super.IterableBase();
       }
       [_jsIterator]() {
         return this[_generator](...this[_args]);
       }
       get iterator() {
-        return new (SyncIterator$(E))(this[_jsIterator]());
+        return new (SyncIterator$(E))(dart.dcall(this[_jsIterator]));
       }
     }
     dart.setSignature(SyncIterable, {
       constructors: () => ({SyncIterable: [SyncIterable$(E), [dart.dynamic, dart.dynamic]]}),
       methods: () => ({[_jsIterator]: [dart.dynamic, []]})
     });
     dart.defineExtensionMembers(SyncIterable, ['iterator']);
     return SyncIterable;
   });
   let SyncIterable = SyncIterable$();
@@ skipping 54 matching lines @@
   exports.CastErrorImplementation = CastErrorImplementation;
   exports.FallThroughErrorImplementation = FallThroughErrorImplementation;
   exports.RuntimeError = RuntimeError;
   exports.random64 = random64;
   exports.jsonEncodeNative = jsonEncodeNative;
   exports.SyncIterator$ = SyncIterator$;
   exports.SyncIterator = SyncIterator;
   exports.SyncIterable$ = SyncIterable$;
   exports.SyncIterable = SyncIterable;
 });