Add --modules=node support

lib/runtime/dart/_runtime.js

 dart_library.library('dart/_runtime', null, /* Imports */[
 ], /* Lazy imports */[
   'dart/core',
   'dart/_interceptors',
   'dart/_js_helper',
   'dart/async',
   'dart/collection'
-], function(exports, core, _interceptors, _js_helper, async$, collection) {
+], function(exports, core, _interceptors, _js_helper, $async, collection) {
   'use strict';
   function mixin(base, ...mixins) {
     class Mixin extends base {
       [base.name](...args) {
         for (let i = mixins.length - 1; i >= 0; i--) {
           let mixin = mixins[i];
           let init = mixin.prototype[mixin.name];
           if (init) init.call(this);
         }
         let init = base.prototype[base.name];
@@ skipping 12 matching lines @@
         return s;
       }
     });
     Mixin[_mixins] = mixins;
     return Mixin;
   }
   function getMixins(clazz) {
     return clazz[_mixins];
   }
   function getImplements(clazz) {
-    return clazz[implements$];
+    return clazz[implements_];
   }
   const _typeArguments = Symbol("typeArguments");
   const _originalDeclaration = Symbol("originalDeclaration");
   function generic(typeConstructor) {
     let length = typeConstructor.length;
     if (length < 1) {
       throwInternalError('must have at least one generic type argument');
     }
     let resultMap = new Map();
     function makeGenericType(...args) {
       if (args.length != length && args.length != 0) {
         throwInternalError('requires ' + length + ' or 0 type arguments');
       }
       while (args.length < length)
-        args.push(dynamic);
+        args.push(dynamicR);
       let value = resultMap;
       for (let i = 0; i < length; i++) {
         let arg = args[i];
         if (arg == null) {
           throwInternalError('type arguments should not be null: ' + typeConstructor);
         }
         let map = value;
         value = map.get(arg);
         if (value === void 0) {
           if (i + 1 == length) {
@@ skipping 37 matching lines @@
     let sigCtor = cls[_constructorSig];
     if (sigCtor === void 0) return void 0;
     let parts = sigCtor[name];
     if (parts === void 0) return void 0;
     return definiteFunctionType.apply(null, parts);
   }
   function bind(obj, name, f) {
     if (f === void 0) f = obj[name];
     f = f.bind(obj);
     let sig = getMethodType(obj, name);
-    assert(sig);
+    assert_(sig);
     tag(f, sig);
     return f;
   }
   function _setMethodSignature(f, sigF) {
     defineMemoizedGetter(f, _methodSig, () => {
       let sigObj = sigF();
       sigObj.__proto__ = f.__proto__[_methodSig];
       return sigObj;
     });
   }
@@ skipping 53 matching lines @@
     let sym = dartx[name];
     if (!sym) dartx[name] = sym = Symbol('dartx.' + name);
     return sym;
   }
   function defineExtensionNames(names) {
     return names.forEach(getExtensionSymbol);
   }
   function registerExtension(jsType, dartExtType) {
     let extProto = dartExtType.prototype;
     let jsProto = jsType.prototype;
-    assert(jsProto[_extensionType] === void 0);
+    assert_(jsProto[_extensionType] === void 0);
     jsProto[_extensionType] = extProto;
     let dartObjProto = core.Object.prototype;
     while (extProto !== dartObjProto && extProto !== jsProto) {
       copyTheseProperties(jsProto, extProto, getOwnPropertySymbols(extProto));
       extProto = extProto.__proto__;
     }
     let originalSigFn = getOwnPropertyDescriptor(dartExtType, _methodSig).get;
-    assert(originalSigFn);
+    assert_(originalSigFn);
     defineMemoizedGetter(jsType, _methodSig, originalSigFn);
   }
   function defineExtensionMembers(type, methodNames) {
     let proto = type.prototype;
     for (let name of methodNames) {
       let method = getOwnPropertyDescriptor(proto, name);
       defineProperty(proto, getExtensionSymbol(name), method);
     }
     let originalSigFn = getOwnPropertyDescriptor(type, _methodSig).get;
     defineMemoizedGetter(type, _methodSig, function() {
@@ skipping 15 matching lines @@
     obj.__proto__ = type.prototype;
     return obj;
   }
   function list(obj, elementType) {
     return setType(obj, getGenericClass(_interceptors.JSArray)(elementType));
   }
   function setBaseClass(derived, base) {
     derived.prototype.__proto__ = base.prototype;
   }
   function throwCastError(actual, type) {
-    throw$(new _js_helper.CastErrorImplementation(actual, type));
+    throw_(new _js_helper.CastErrorImplementation(actual, type));
   }
   function throwAssertionError() {
-    throw$(new core.AssertionError());
+    throw_(new core.AssertionError());
   }
   function throwNullValueError() {
-    throw$(new core.NoSuchMethodError(null, new core.Symbol('<Unexpected Null Value>'), null, null, null));
+    throw_(new core.NoSuchMethodError(null, new core.Symbol('<Unexpected Null Value>'), null, null, null));
   }
   const _jsIterator = Symbol("_jsIterator");
   const _current = Symbol("_current");
   function syncStar(gen, E, ...args) {
     const SyncIterable_E = getGenericClass(_js_helper.SyncIterable)(E);
     return new SyncIterable_E(gen, args);
   }
-  function async(gen, T, ...args) {
+  function async_(gen, T, ...args) {
     let iter;
     function onValue(res) {
       if (res === void 0) res = null;
       return next(iter.next(res));
     }
     function onError(err) {
       return next(iter.throw(err));
     }
     function next(ret) {
       if (ret.done) return ret.value;
       let future = ret.value;
-      if (!instanceOf(future, getGenericClass(async$.Future))) {
-        future = async$.Future.value(future);
+      if (!instanceOf(future, getGenericClass($async.Future))) {
+        future = $async.Future.value(future);
       }
       return future.then(onValue, {onError: onError});
     }
-    return getGenericClass(async$.Future)(T).new(function() {
+    return getGenericClass($async.Future)(T).new(function() {
       iter = gen(...args)[Symbol.iterator]();
       return onValue();
     });
   }
   const _AsyncStarStreamController = class _AsyncStarStreamController {
     constructor(generator, T, args) {
       this.isAdding = false;
       this.isWaiting = false;
       this.isScheduled = false;
       this.isSuspendedAtYield = false;
       this.canceler = null;
       this.iterator = generator(this, ...args)[Symbol.iterator]();
-      this.controller = getGenericClass(async$.StreamController)(T).new({
+      this.controller = getGenericClass($async.StreamController)(T).new({
         onListen: (() => this.scheduleGenerator()).bind(this),
         onResume: (() => this.onResume()).bind(this),
         onCancel: (() => this.onCancel()).bind(this)
       });
     }
     onResume() {
       if (this.isSuspendedAtYield) {
         this.scheduleGenerator();
       }
     }
     onCancel() {
       if (this.controller.isClosed) {
         return null;
       }
       if (this.canceler == null) {
-        this.canceler = async$.Completer.new();
+        this.canceler = $async.Completer.new();
         this.scheduleGenerator();
       }
       return this.canceler.future;
     }
     close() {
       if (this.canceler != null && !this.canceler.isCompleted) {
         this.canceler.complete();
       }
       this.controller.close();
     }
     scheduleGenerator() {
       if (this.isScheduled || this.controller.isPaused || this.isAdding || this.isWaiting) {
         return;
       }
       this.isScheduled = true;
-      async$.scheduleMicrotask((() => this.runBody()).bind(this));
+      $async.scheduleMicrotask((() => this.runBody()).bind(this));
     }
     runBody(opt_awaitValue) {
       this.isScheduled = false;
       this.isSuspendedAtYield = false;
       this.isWaiting = false;
       let iter;
       try {
         iter = this.iterator.next(opt_awaitValue);
       } catch (e) {
         this.addError(e, stackTrace(e));
         this.close();
         return;
       }
 
       if (iter.done) {
         this.close();
         return;
       }
       if (this.isSuspendedAtYield || this.isAdding) return;
       this.isWaiting = true;
       let future = iter.value;
-      if (!instanceOf(future, getGenericClass(async$.Future))) {
-        future = async$.Future.value(future);
+      if (!instanceOf(future, getGenericClass($async.Future))) {
+        future = $async.Future.value(future);
       }
       return future.then((x => this.runBody(x)).bind(this), {
         onError: ((e, s) => this.throwError(e, s)).bind(this)
       });
     }
     add(event) {
       if (!this.controller.hasListener) return true;
       this.controller.add(event);
       this.scheduleGenerator();
       this.isSuspendedAtYield = true;
@@ skipping 70 matching lines @@
     if (names.length == 0) return false;
     for (var name of names) {
       if (!hasOwnProperty.call(type.named, name)) {
         return false;
       }
       if (!instanceOfOrNull(opts[name], type.named[name])) return false;
     }
     return true;
   }
   function throwNoSuchMethod(obj, name, pArgs, nArgs, extras) {
-    throw$(new core.NoSuchMethodError(obj, name, pArgs, nArgs, extras));
+    throw_(new core.NoSuchMethodError(obj, name, pArgs, nArgs, extras));
   }
   function throwNoSuchMethodFunc(obj, name, pArgs, opt_func) {
     if (obj === void 0) obj = opt_func;
     throwNoSuchMethod(obj, name, pArgs);
   }
   function checkAndCall(f, ftype, obj, args, name) {
     let originalFunction = f;
     if (!(f instanceof Function)) {
       if (f != null) {
         ftype = getMethodType(f, 'call');
@@ skipping 28 matching lines @@
     return callMethod(obj, method, args, method);
   }
   function dindex(obj, index) {
     return callMethod(obj, 'get', [index], '[]');
   }
   function dsetindex(obj, index, value) {
     callMethod(obj, 'set', [index, value], '[]=');
     return value;
   }
   function _ignoreTypeFailure(actual, type) {
-    if (isSubtype(type, core.Iterable) && isSubtype(actual, core.Iterable) || isSubtype(type, async$.Future) && isSubtype(actual, async$.Future) || isSubtype(type, core.Map) && isSubtype(actual, core.Map) || isSubtype(type, core.Function) && isSubtype(actual, core.Function) || isSubtype(type, async$.Stream) && isSubtype(actual, async$.Stream) || isSubtype(type, async$.StreamSubscription) && isSubtype(actual, async$.StreamSubscription)) {
+    if (isSubtype(type, core.Iterable) && isSubtype(actual, core.Iterable) || isSubtype(type, $async.Future) && isSubtype(actual, $async.Future) || isSubtype(type, core.Map) && isSubtype(actual, core.Map) || isSubtype(type, core.Function) && isSubtype(actual, core.Function) || isSubtype(type, $async.Stream) && isSubtype(actual, $async.Stream) || isSubtype(type, $async.StreamSubscription) && isSubtype(actual, $async.StreamSubscription)) {
       console.warn('Ignoring cast fail from ' + typeName(actual) + ' to ' + typeName(type));
       return true;
     }
     return false;
   }
   function strongInstanceOf(obj, type, ignoreFromWhiteList) {
     let actual = realRuntimeType(obj);
     if (isSubtype(actual, type) || actual == jsobject) return true;
     if (ignoreFromWhiteList == void 0) return false;
     if (isGroundType(type)) return false;
@@ skipping 46 matching lines @@
         let value = values[i + 1];
         map.set(key, value);
       }
     } else if (typeof values === 'object') {
       for (let key of getOwnPropertyNames(values)) {
         map.set(key, values[key]);
       }
     }
     return map;
   }
-  function assert(condition) {
+  function assert_(condition) {
     if (!condition) throwAssertionError();
   }
   const _stack = new WeakMap();
-  function throw$(obj) {
+  function throw_(obj) {
     if (obj != null && (typeof obj == 'object' || typeof obj == 'function')) {
       _stack.set(obj, new Error());
     }
     throw obj;
   }
   function getError(exception) {
     var stack = _stack.get(exception);
     return stack !== void 0 ? stack : exception;
   }
   function stackPrint(exception) {
@@ skipping 20 matching lines @@
         map.set(k, value = new Map());
       }
       map = value;
     }
     if (map.has(_value)) return map.get(_value);
     let value = valueFn();
     map.set(_value, value);
     return value;
   }
   const constants = new Map();
-  function const$(obj) {
+  function const_(obj) {
     let objectKey = [realRuntimeType(obj)];
     for (let name of getOwnNamesAndSymbols(obj)) {
       objectKey.push(name);
       objectKey.push(obj[name]);
     }
     return multiKeyPutIfAbsent(constants, objectKey, () => obj);
   }
   function hashCode(obj) {
     if (obj == null) {
       return 0;
@@ skipping 41 matching lines @@
       return {done: done, value: done ? void 0 : i.current};
     }
   };
   function fn(closure, ...args) {
     if (args.length == 1) {
       defineLazyProperty(closure, _runtimeType, {get: args[0]});
       return closure;
     }
     let t;
     if (args.length == 0) {
-      t = definiteFunctionType(dynamic, Array(closure.length).fill(dynamic));
+      t = definiteFunctionType(dynamicR, Array(closure.length).fill(dynamicR));
     } else {
       t = definiteFunctionType.apply(null, args);
     }
     tag(closure, t);
     return closure;
   }
   const _runtimeType = Symbol("_runtimeType");
   function checkPrimitiveType(obj) {
     switch (typeof obj) {
       case "undefined":
@@ skipping 19 matching lines @@
     }
     if (obj === null) return core.Null;
     return null;
   }
   function runtimeType(obj) {
     let result = checkPrimitiveType(obj);
     if (result !== null) return result;
     return obj.runtimeType;
   }
   function getFunctionType(obj) {
-    let args = Array(obj.length).fill(dynamic);
+    let args = Array(obj.length).fill(dynamicR);
     return definiteFunctionType(bottom, args);
   }
   function realRuntimeType(obj) {
     let result = checkPrimitiveType(obj);
     if (result !== null) return result;
     result = obj[_runtimeType];
     if (result) return result;
     result = obj.constructor;
     if (result == Function) {
       return jsobject;
@@ skipping 21 matching lines @@
     let cache = null;
     function getter() {
       if (compute == null) return cache;
       cache = compute();
       compute = null;
       return cache;
     }
     tagComputed(value, getter);
   }
   const _mixins = Symbol("mixins");
-  const implements$ = Symbol("implements");
+  const implements_ = Symbol("implements");
   const metadata = Symbol("metadata");
   const TypeRep = class TypeRep extends LazyTagged(() => core.Type) {
     get name() {
       return this.toString();
     }
   };
   const Dynamic = class Dynamic extends TypeRep {
     toString() {
       return "dynamic";
     }
   };
-  const dynamic = new Dynamic();
+  const dynamicR = new Dynamic();
   const Void = class Void extends TypeRep {
     toString() {
       return "void";
     }
   };
-  const void$ = new Void();
+  const voidR = new Void();
   const Bottom = class Bottom extends TypeRep {
     toString() {
       return "bottom";
     }
   };
   const bottom = new Bottom();
   const JSObject = class JSObject extends TypeRep {
     toString() {
       return "NativeJavaScriptObject";
     }
@@ skipping 66 matching lines @@
         }
         return result;
       }
       this.args = process(this.args, this.metadata);
       this.optionals = process(this.optionals, this.metadata);
       this._canonize();
     }
     _canonize() {
       if (this.definite) return;
       function replace(a) {
-        return a == dynamic ? bottom : a;
+        return a == dynamicR ? bottom : a;
       }
       this.args = this.args.map(replace);
       if (this.optionals.length > 0) {
         this.optionals = this.optionals.map(replace);
       }
       if (Object.keys(this.named).length > 0) {
         let r = {};
         for (let name of getOwnPropertyNames(this.named)) {
           r[name] = replace(this.named[name]);
         }
@@ skipping 85 matching lines @@
   function isFunctionType(type) {
     return type instanceof AbstractFunctionType || type == core.Function;
   }
   function isFunctionSubType(ft1, ft2) {
     if (ft2 == core.Function) {
       return true;
     }
     let ret1 = ft1.returnType;
     let ret2 = ft2.returnType;
     if (!isSubtype_(ret1, ret2)) {
-      if (ret2 != void$) {
+      if (ret2 != voidR) {
         return false;
       }
     }
     let args1 = ft1.args;
     let args2 = ft2.args;
     if (args1.length > args2.length) {
       return false;
     }
     for (let i = 0; i < args1.length; ++i) {
       if (!isSubtype_(args2[i], args1[i])) {
@@ skipping 52 matching lines @@
       subtypeMap.set(t1, map = new Map());
     }
     result = isSubtype_(t1, t2);
     map.set(t2, result);
     return result;
   }
   function _isBottom(type) {
     return type == bottom;
   }
   function _isTop(type) {
-    return type == core.Object || type == dynamic;
+    return type == core.Object || type == dynamicR;
   }
   function isSubtype_(t1, t2) {
     t1 = canonicalType(t1);
     t2 = canonicalType(t2);
     if (t1 == t2) return true;
     if (_isTop(t2) || _isBottom(t1)) {
       return true;
     }
     if (_isTop(t1) || _isBottom(t2)) {
       return false;
     }
     if (isClassSubType(t1, t2)) {
       return true;
     }
     if (isFunctionType(t1) && isFunctionType(t2)) {
       return isFunctionSubType(t1, t2);
     }
     return false;
   }
   function isClassSubType(t1, t2) {
     t1 = canonicalType(t1);
-    assert(t2 == canonicalType(t2));
+    assert_(t2 == canonicalType(t2));
     if (t1 == t2) return true;
     if (t1 == core.Object) return false;
-    if (t1 == null) return t2 == core.Object || t2 == dynamic;
+    if (t1 == null) return t2 == core.Object || t2 == dynamicR;
     let raw1 = getGenericClass(t1);
     let raw2 = getGenericClass(t2);
     if (raw1 != null && raw1 == raw2) {
       let typeArguments1 = getGenericArgs(t1);
       let typeArguments2 = getGenericArgs(t2);
       let length = typeArguments1.length;
       if (typeArguments2.length == 0) {
         return true;
       } else if (length == 0) {
         return false;
       }
-      assert(length == typeArguments2.length);
+      assert_(length == typeArguments2.length);
       for (let i = 0; i < length; ++i) {
         if (!isSubtype(typeArguments1[i], typeArguments2[i])) {
           return false;
         }
       }
       return true;
     }
     if (isClassSubType(t1.__proto__, t2)) return true;
     let mixins = getMixins(t1);
     if (mixins) {
@@ skipping 20 matching lines @@
       }
       let names = getOwnPropertyNames(type.named);
       for (let i = 0; i < names.length; ++i) {
         if (!_isBottom(type.named[names[i]])) return false;
       }
       return true;
     }
     let typeArgs = getGenericArgs(type);
     if (!typeArgs) return true;
     for (let t of typeArgs) {
-      if (t != core.Object && t != dynamic) return false;
+      if (t != core.Object && t != dynamicR) return false;
     }
     return true;
   }
   const defineProperty = Object.defineProperty;
   const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
   const getOwnPropertyNames = Object.getOwnPropertyNames;
   const getOwnPropertySymbols = Object.getOwnPropertySymbols;
   const hasOwnProperty = Object.prototype.hasOwnProperty;
   const StrongModeError = (function() {
     function StrongModeError(message) {
@@ skipping 54 matching lines @@
         defineProperty(to, name, desc);
       } else {
         defineLazyProperty(to, name, () => from[name]);
       }
     }
     return to;
   }
   function copyProperties(to, from) {
     return copyTheseProperties(to, from, getOwnNamesAndSymbols(from));
   }
-  function export$(to, from, show, hide) {
+  function export_(to, from, show, hide) {
     if (show == void 0 || show.length == 0) {
       show = getOwnNamesAndSymbols(from);
     }
     if (hide != void 0) {
       var hideMap = new Set(hide);
       show = show.filter(k => !hideMap.has(k));
     }
     return copyTheseProperties(to, from, show);
   }
   const defineLazyClass = defineLazy;
   const defineLazyProperties = defineLazy;
   const defineLazyClassGeneric = defineLazyProperty;
-  const as = cast;
-  const is = instanceOf;
-  const global = typeof window == "undefined" ? global : window;
+  const as_ = cast;
+  const is_ = instanceOf;
+  const global_ = typeof window == "undefined" ? global : window;
   const JsSymbol = Symbol;
   // Exports:
   exports.mixin = mixin;
   exports.getMixins = getMixins;
   exports.getImplements = getImplements;
   exports.generic = generic;
   exports.getGenericClass = getGenericClass;
   exports.getGenericArgs = getGenericArgs;
   exports.getMethodType = getMethodType;
   exports.classGetConstructorType = classGetConstructorType;
   exports.bind = bind;
   exports.setSignature = setSignature;
   exports.hasMethod = hasMethod;
   exports.virtualField = virtualField;
   exports.defineNamedConstructor = defineNamedConstructor;
   exports.dartx = dartx;
   exports.getExtensionSymbol = getExtensionSymbol;
   exports.defineExtensionNames = defineExtensionNames;
   exports.registerExtension = registerExtension;
   exports.defineExtensionMembers = defineExtensionMembers;
   exports.canonicalMember = canonicalMember;
   exports.setType = setType;
   exports.list = list;
   exports.setBaseClass = setBaseClass;
   exports.throwCastError = throwCastError;
   exports.throwAssertionError = throwAssertionError;
   exports.throwNullValueError = throwNullValueError;
   exports.syncStar = syncStar;
-  exports.async = async;
+  exports.async = async_;
   exports.asyncStar = asyncStar;
   exports.dload = dload;
   exports.dput = dput;
   exports.checkApply = checkApply;
   exports.throwNoSuchMethod = throwNoSuchMethod;
   exports.throwNoSuchMethodFunc = throwNoSuchMethodFunc;
   exports.checkAndCall = checkAndCall;
   exports.dcall = dcall;
   exports.callMethod = callMethod;
   exports.dsend = dsend;
   exports.dindex = dindex;
   exports.dsetindex = dsetindex;
   exports.strongInstanceOf = strongInstanceOf;
   exports.instanceOfOrNull = instanceOfOrNull;
   exports.instanceOf = instanceOf;
   exports.cast = cast;
   exports.asInt = asInt;
   exports.arity = arity;
   exports.equals = equals;
   exports.notNull = notNull;
   exports.map = map;
-  exports.assert = assert;
-  exports.throw = throw$;
+  exports.assert = assert_;
+  exports.throw = throw_;
   exports.getError = getError;
   exports.stackPrint = stackPrint;
   exports.stackTrace = stackTrace;
   exports.nullSafe = nullSafe;
   exports.multiKeyPutIfAbsent = multiKeyPutIfAbsent;
   exports.constants = constants;
-  exports.const = const$;
+  exports.const = const_;
   exports.hashCode = hashCode;
   exports.toString = toString;
   exports.noSuchMethod = noSuchMethod;
   exports.JsIterator = JsIterator;
   exports.fn = fn;
   exports.checkPrimitiveType = checkPrimitiveType;
   exports.runtimeType = runtimeType;
   exports.getFunctionType = getFunctionType;
   exports.realRuntimeType = realRuntimeType;
   exports.LazyTagged = LazyTagged;
   exports.read = read;
   exports.tag = tag;
   exports.tagComputed = tagComputed;
   exports.tagMemoized = tagMemoized;
-  exports.implements = implements$;
+  exports.implements = implements_;
   exports.metadata = metadata;
   exports.TypeRep = TypeRep;
   exports.Dynamic = Dynamic;
-  exports.dynamic = dynamic;
+  exports.dynamic = dynamicR;
   exports.Void = Void;
-  exports.void = void$;
+  exports.void = voidR;
   exports.Bottom = Bottom;
   exports.bottom = bottom;
   exports.JSObject = JSObject;
   exports.jsobject = jsobject;
   exports.AbstractFunctionType = AbstractFunctionType;
   exports.FunctionType = FunctionType;
   exports.Typedef = Typedef;
   exports.functionType = functionType;
   exports.definiteFunctionType = definiteFunctionType;
   exports.typedef = typedef;
@@ skipping 15 matching lines @@
   exports.StrongModeError = StrongModeError;
   exports.throwStrongModeError = throwStrongModeError;
   exports.throwInternalError = throwInternalError;
   exports.getOwnNamesAndSymbols = getOwnNamesAndSymbols;
   exports.safeGetOwnProperty = safeGetOwnProperty;
   exports.defineLazyProperty = defineLazyProperty;
   exports.defineLazy = defineLazy;
   exports.defineMemoizedGetter = defineMemoizedGetter;
   exports.copyTheseProperties = copyTheseProperties;
   exports.copyProperties = copyProperties;
-  exports.export = export$;
+  exports.export = export_;
   exports.defineLazyClass = defineLazyClass;
   exports.defineLazyProperties = defineLazyProperties;
   exports.defineLazyClassGeneric = defineLazyClassGeneric;
-  exports.as = as;
-  exports.is = is;
-  exports.global = global;
+  exports.as = as_;
+  exports.is = is_;
+  exports.global = global_;
   exports.JsSymbol = JsSymbol;
 });