fixes #69, avoid module name inside module scope

test/codegen/expect/_isolate_helper/_isolate_helper.js

 var _isolate_helper;
-(function(_isolate_helper) {
+(function(exports) {
   'use strict';
   // Function _callInIsolate: (_IsolateContext, Function) → dynamic
   function _callInIsolate(isolate, function) {
     let result = isolate.eval(function);
-    _isolate_helper._globalState.topEventLoop.run();
+    exports._globalState.topEventLoop.run();
     return result;
   }
   // Function enterJsAsync: () → dynamic
   function enterJsAsync() {
-    _isolate_helper._globalState.topEventLoop._activeJsAsyncCount++;
+    exports._globalState.topEventLoop._activeJsAsyncCount++;
   }
   // Function leaveJsAsync: () → dynamic
   function leaveJsAsync() {
-    _isolate_helper._globalState.topEventLoop._activeJsAsyncCount--;
-    dart.assert(_isolate_helper._globalState.topEventLoop._activeJsAsyncCount >= 0);
+    exports._globalState.topEventLoop._activeJsAsyncCount--;
+    dart.assert(exports._globalState.topEventLoop._activeJsAsyncCount >= 0);
   }
   // Function isWorker: () → bool
   function isWorker() {
-    return _isolate_helper._globalState.isWorker;
+    return exports._globalState.isWorker;
   }
   // Function _currentIsolate: () → _IsolateContext
   function _currentIsolate() {
-    return _isolate_helper._globalState.currentContext;
+    return exports._globalState.currentContext;
   }
   // Function startRootIsolate: (dynamic, dynamic) → void
   function startRootIsolate(entry, args) {
     args = args;
     if (args === null)
       args = new List.from([]);
     if (!dart.is(args, core.List)) {
       throw new core.ArgumentError(`Arguments to main must be a List: ${args}`);
     }
-    _isolate_helper._globalState = new _Manager(dart.as(entry, core.Function));
-    if (_isolate_helper._globalState.isWorker)
+    exports._globalState = new _Manager(dart.as(entry, core.Function));
+    if (exports._globalState.isWorker)
       return;
     let rootContext = new _IsolateContext();
-    _isolate_helper._globalState.rootContext = rootContext;
-    _isolate_helper._globalState.currentContext = rootContext;
+    exports._globalState.rootContext = rootContext;
+    exports._globalState.currentContext = rootContext;
     if (dart.is(entry, _MainFunctionArgs)) {
       rootContext.eval(() => {
         dart.dinvokef(entry, args);
       });
     } else if (dart.is(entry, _MainFunctionArgsMessage)) {
       rootContext.eval(() => {
         dart.dinvokef(entry, args, null);
       });
     } else {
       rootContext.eval(dart.as(entry, core.Function));
     }
-    _isolate_helper._globalState.topEventLoop.run();
+    exports._globalState.topEventLoop.run();
   }
-  dart.copyProperties(_isolate_helper, {
+  dart.copyProperties(exports, {
     get _globalState() {
       return dart.as(init.globalState, _Manager);
     },
     set _globalState(val) {
       init.globalState = val;
     }
   });
   class _Manager extends dart.Object {
     get useWorkers() {
       return this.supportsWorkers;
@@ skipping 15 matching lines @@
       this._nativeDetectEnvironment();
       this.topEventLoop = new _EventLoop();
       this.isolates = new core.Map();
       this.managers = new core.Map();
       if (this.isWorker) {
         this.mainManager = new _MainManagerStub();
         this._nativeInitWorkerMessageHandler();
       }
     }
     _nativeDetectEnvironment() {
-      let isWindowDefined = _isolate_helper.globalWindow !== null;
-      let isWorkerDefined = _isolate_helper.globalWorker !== null;
-      this.isWorker = dart.notNull(!dart.notNull(isWindowDefined)) && dart.notNull(_isolate_helper.globalPostMessageDefined);
+      let isWindowDefined = exports.globalWindow !== null;
+      let isWorkerDefined = exports.globalWorker !== null;
+      this.isWorker = dart.notNull(!dart.notNull(isWindowDefined)) && dart.notNull(exports.globalPostMessageDefined);
       this.supportsWorkers = dart.notNull(this.isWorker) || dart.notNull(dart.notNull(isWorkerDefined) && dart.notNull(IsolateNatives.thisScript !== null));
       this.fromCommandLine = dart.notNull(!dart.notNull(isWindowDefined)) && dart.notNull(!dart.notNull(this.isWorker));
     }
     _nativeInitWorkerMessageHandler() {
       let function = function(f, a) {
         return function(e) {
           f(a, e);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(IsolateNatives._processWorkerMessage), this.mainManager);
       self.onmessage = function;
@@ skipping 11 matching lines @@
       return _serializeMessage(dart.map({command: "print", msg: object}));
     }
     maybeCloseWorker() {
       if (dart.notNull(dart.notNull(this.isWorker) && dart.notNull(this.isolates.isEmpty)) && dart.notNull(this.topEventLoop._activeJsAsyncCount === 0)) {
         this.mainManager.postMessage(_serializeMessage(dart.map({command: 'close'})));
       }
     }
   }
   class _IsolateContext extends dart.Object {
     _IsolateContext() {
-      this.id = _isolate_helper._globalState.nextIsolateId++;
+      this.id = exports._globalState.nextIsolateId++;
       this.ports = new core.Map();
       this.weakPorts = new core.Set();
       this.isolateStatics = _foreign_helper.JS_CREATE_ISOLATE();
       this.controlPort = new RawReceivePortImpl._controlPort();
       this.pauseCapability = new isolate.Capability();
       this.terminateCapability = new isolate.Capability();
       this.delayedEvents = dart.as(new List.from([]), core.List$(_IsolateEvent));
       this.pauseTokens = dart.as(new core.Set(), core.Set$(isolate.Capability));
       this.errorPorts = dart.as(new core.Set(), core.Set$(isolate.SendPort));
       this.initialized = false;
@@ skipping 12 matching lines @@
       }
       this._updateGlobalState();
     }
     removePause(resume) {
       if (!dart.notNull(this.isPaused))
         return;
       this.pauseTokens.remove(resume);
       if (this.pauseTokens.isEmpty) {
         while (this.delayedEvents.isNotEmpty) {
           let event = this.delayedEvents.removeLast();
-          _isolate_helper._globalState.topEventLoop.prequeue(event);
+          exports._globalState.topEventLoop.prequeue(event);
         }
         this.isPaused = false;
       }
       this._updateGlobalState();
     }
     addDoneListener(responsePort) {
       if (this.doneHandlers === null) {
         this.doneHandlers = new List.from([]);
       }
       if (dart.dinvoke(this.doneHandlers, 'contains', responsePort))
@@ skipping 13 matching lines @@
     handlePing(responsePort, pingType) {
       if (dart.notNull(pingType === isolate.Isolate.IMMEDIATE) || dart.notNull(dart.notNull(pingType === isolate.Isolate.BEFORE_NEXT_EVENT) && dart.notNull(!dart.notNull(this._isExecutingEvent)))) {
         responsePort.send(null);
         return;
       }
       // Function respond: () → void
       function respond() {
         responsePort.send(null);
       }
       if (pingType === isolate.Isolate.AS_EVENT) {
-        _isolate_helper._globalState.topEventLoop.enqueue(this, respond, "ping");
+        exports._globalState.topEventLoop.enqueue(this, respond, "ping");
         return;
       }
       dart.assert(pingType === isolate.Isolate.BEFORE_NEXT_EVENT);
       if (this._scheduledControlEvents === null) {
         this._scheduledControlEvents = new collection.Queue();
       }
       dart.dinvoke(this._scheduledControlEvents, 'addLast', respond);
     }
     handleKill(authentification, priority) {
       if (!dart.equals(this.terminateCapability, authentification))
         return;
       if (dart.notNull(priority === isolate.Isolate.IMMEDIATE) || dart.notNull(dart.notNull(priority === isolate.Isolate.BEFORE_NEXT_EVENT) && dart.notNull(!dart.notNull(this._isExecutingEvent)))) {
         this.kill();
         return;
       }
       if (priority === isolate.Isolate.AS_EVENT) {
-        _isolate_helper._globalState.topEventLoop.enqueue(this, this.kill, "kill");
+        exports._globalState.topEventLoop.enqueue(this, this.kill, "kill");
         return;
       }
       dart.assert(priority === isolate.Isolate.BEFORE_NEXT_EVENT);
       if (this._scheduledControlEvents === null) {
         this._scheduledControlEvents = new collection.Queue();
       }
       dart.dinvoke(this._scheduledControlEvents, 'addLast', this.kill);
     }
     addErrorListener(port) {
       this.errorPorts.add(port);
     }
     removeErrorListener(port) {
       this.errorPorts.remove(port);
     }
     handleUncaughtError(error, stackTrace) {
       if (this.errorPorts.isEmpty) {
-        if (dart.notNull(this.errorsAreFatal) && dart.notNull(core.identical(this, _isolate_helper._globalState.rootContext))) {
+        if (dart.notNull(this.errorsAreFatal) && dart.notNull(core.identical(this, exports._globalState.rootContext))) {
           return;
         }
         if (self.console && self.console.error) {
           self.console.error(error, stackTrace);
         } else {
           core.print(error);
           if (stackTrace !== null)
             core.print(stackTrace);
         }
         return;
       }
       let message = new core.List(2);
       message.set(0, dart.dinvoke(error, 'toString'));
       message.set(1, stackTrace === null ? null : stackTrace.toString());
       for (let port of this.errorPorts)
         port.send(message);
     }
     eval(code) {
-      let old = _isolate_helper._globalState.currentContext;
-      _isolate_helper._globalState.currentContext = this;
+      let old = exports._globalState.currentContext;
+      exports._globalState.currentContext = this;
       this._setGlobals();
       let result = null;
       this._isExecutingEvent = true;
       try {
         result = dart.dinvokef(code);
       } catch (e) {
         let s = dart.stackTrace(e);
         this.handleUncaughtError(e, s);
         if (this.errorsAreFatal) {
           this.kill();
-          if (core.identical(this, _isolate_helper._globalState.rootContext)) {
+          if (core.identical(this, exports._globalState.rootContext)) {
             dart.throw_("Unimplemented RethrowExpression: rethrow");
           }
         }
       }
  finally {
         this._isExecutingEvent = false;
-        _isolate_helper._globalState.currentContext = old;
+        exports._globalState.currentContext = old;
         if (old !== null)
           old._setGlobals();
         if (this._scheduledControlEvents !== null) {
           while (dart.dload(this._scheduledControlEvents, 'isNotEmpty')) {
             dart.dinvokef(dart.dinvoke(this._scheduledControlEvents, 'removeFirst'));
           }
         }
       }
       return result;
     }
@@ skipping 44 matching lines @@
     register(portId, port) {
       this._addRegistration(portId, port);
       this._updateGlobalState();
     }
     registerWeak(portId, port) {
       this.weakPorts.add(portId);
       this._addRegistration(portId, port);
     }
     _updateGlobalState() {
       if (dart.notNull(dart.notNull(this.ports.length - this.weakPorts.length > 0) || dart.notNull(this.isPaused)) || dart.notNull(!dart.notNull(this.initialized))) {
-        _isolate_helper._globalState.isolates.set(this.id, this);
+        exports._globalState.isolates.set(this.id, this);
       } else {
         this.kill();
       }
     }
     kill() {
       if (this._scheduledControlEvents !== null) {
         dart.dinvoke(this._scheduledControlEvents, 'clear');
       }
       for (let port of this.ports.values) {
         dart.dinvoke(port, '_close');
       }
       this.ports.clear();
       this.weakPorts.clear();
-      _isolate_helper._globalState.isolates.remove(this.id);
+      exports._globalState.isolates.remove(this.id);
       this.errorPorts.clear();
       if (this.doneHandlers !== null) {
         for (let port of this.doneHandlers) {
           port.send(null);
         }
         this.doneHandlers = null;
       }
     }
     unregister(portId) {
       this.ports.remove(portId);
@@ skipping 11 matching lines @@
     }
     prequeue(event) {
       this.events.addFirst(event);
     }
     dequeue() {
       if (this.events.isEmpty)
         return null;
       return this.events.removeFirst();
     }
     checkOpenReceivePortsFromCommandLine() {
-      if (dart.notNull(dart.notNull(dart.notNull(_isolate_helper._globalState.rootContext !== null) && dart.notNull(_isolate_helper._globalState.isolates.containsKey(_isolate_helper._globalState.rootContext.id))) && dart.notNull(_isolate_helper._globalState.fromCommandLine)) && dart.notNull(_isolate_helper._globalState.rootContext.ports.isEmpty)) {
+      if (dart.notNull(dart.notNull(dart.notNull(exports._globalState.rootContext !== null) && dart.notNull(exports._globalState.isolates.containsKey(exports._globalState.rootContext.id))) && dart.notNull(exports._globalState.fromCommandLine)) && dart.notNull(exports._globalState.rootContext.ports.isEmpty)) {
         throw new core.Exception("Program exited with open ReceivePorts.");
       }
     }
     runIteration() {
       let event = this.dequeue();
       if (event === null) {
         this.checkOpenReceivePortsFromCommandLine();
-        _isolate_helper._globalState.maybeCloseWorker();
+        exports._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
       return true;
     }
     _runHelper() {
-      if (_isolate_helper.globalWindow !== null) {
+      if (exports.globalWindow !== null) {
         // Function next: () → void
         function next() {
           if (!dart.notNull(this.runIteration()))
             return;
           async.Timer.run(next);
         }
         next();
       } else {
         while (this.runIteration()) {
         }
       }
     }
     run() {
-      if (!dart.notNull(_isolate_helper._globalState.isWorker)) {
+      if (!dart.notNull(exports._globalState.isWorker)) {
         this._runHelper();
       } else {
         try {
           this._runHelper();
         } catch (e) {
           let trace = dart.stackTrace(e);
-          _isolate_helper._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'error', msg: `${e}\n${trace}`})));
+          exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'error', msg: `${e}\n${trace}`})));
         }
 
       }
     }
   }
   class _IsolateEvent extends dart.Object {
     _IsolateEvent(isolate, fn, message) {
       this.isolate = isolate;
       this.fn = fn;
       this.message = message;
     }
     process() {
       if (this.isolate.isPaused) {
         this.isolate.delayedEvents.add(this);
         return;
       }
       this.isolate.eval(this.fn);
     }
   }
   class _MainManagerStub extends dart.Object {
     postMessage(msg) {
       _js_helper.requiresPreamble();
       self.postMessage(msg);
     }
   }
   let _SPAWNED_SIGNAL = "spawned";
   let _SPAWN_FAILED_SIGNAL = "spawn failed";
-  dart.copyProperties(_isolate_helper, {
+  dart.copyProperties(exports, {
     get globalWindow() {
       _js_helper.requiresPreamble();
       return self.window;
     },
     get globalWorker() {
       _js_helper.requiresPreamble();
       return self.Worker;
     },
     get globalPostMessageDefined() {
       _js_helper.requiresPreamble();
       return !!self.postMessage;
     }
   });
   class IsolateNatives extends dart.Object {
     static computeThisScript() {
       let currentScript = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.CURRENT_SCRIPT, core.String));
       if (currentScript !== null) {
         return String(currentScript.src);
       }
       if (_js_helper.Primitives.isD8)
         return computeThisScriptD8();
       if (_js_helper.Primitives.isJsshell)
         return computeThisScriptJsshell();
-      if (_isolate_helper._globalState.isWorker)
+      if (exports._globalState.isWorker)
         return computeThisScriptFromTrace();
       return null;
     }
     static computeThisScriptJsshell() {
       return dart.as(thisFilename(), core.String);
     }
     static computeThisScriptD8() {
       return computeThisScriptFromTrace();
     }
     static computeThisScriptFromTrace() {
@@ skipping 21 matching lines @@
         return matches[1];
       throw new core.UnsupportedError(`Cannot extract URI from "${stack}"`);
     }
     static _getEventData(e) {
       return e.data;
     }
     static _processWorkerMessage(sender, e) {
       let msg = _deserializeMessage(_getEventData(e));
       switch (dart.dindex(msg, 'command')) {
         case 'start':
-          _isolate_helper._globalState.currentManagerId = dart.as(dart.dindex(msg, 'id'), core.int);
+          exports._globalState.currentManagerId = dart.as(dart.dindex(msg, 'id'), core.int);
           let functionName = dart.as(dart.dindex(msg, 'functionName'), core.String);
-          let entryPoint = dart.as(functionName === null ? _isolate_helper._globalState.entry : _getJSFunctionFromName(functionName), core.Function);
+          let entryPoint = dart.as(functionName === null ? exports._globalState.entry : _getJSFunctionFromName(functionName), core.Function);
           let args = dart.dindex(msg, 'args');
           let message = _deserializeMessage(dart.dindex(msg, 'msg'));
           let isSpawnUri = dart.dindex(msg, 'isSpawnUri');
           let startPaused = dart.dindex(msg, 'startPaused');
           let replyTo = _deserializeMessage(dart.dindex(msg, 'replyTo'));
           let context = new _IsolateContext();
-          _isolate_helper._globalState.topEventLoop.enqueue(context, () => {
+          exports._globalState.topEventLoop.enqueue(context, () => {
             _startIsolate(entryPoint, dart.as(args, core.List$(core.String)), message, dart.as(isSpawnUri, core.bool), dart.as(startPaused, core.bool), dart.as(replyTo, isolate.SendPort));
           }, 'worker-start');
-          _isolate_helper._globalState.currentContext = context;
-          _isolate_helper._globalState.topEventLoop.run();
+          exports._globalState.currentContext = context;
+          exports._globalState.topEventLoop.run();
           break;
         case 'spawn-worker':
           if (enableSpawnWorker !== null)
             handleSpawnWorkerRequest(msg);
           break;
         case 'message':
           let port = dart.as(dart.dindex(msg, 'port'), isolate.SendPort);
           if (port !== null) {
             dart.dinvoke(dart.dindex(msg, 'port'), 'send', dart.dindex(msg, 'msg'));
           }
-          _isolate_helper._globalState.topEventLoop.run();
+          exports._globalState.topEventLoop.run();
           break;
         case 'close':
-          _isolate_helper._globalState.managers.remove(workerIds.get(sender));
+          exports._globalState.managers.remove(workerIds.get(sender));
           sender.terminate();
-          _isolate_helper._globalState.topEventLoop.run();
+          exports._globalState.topEventLoop.run();
           break;
         case 'log':
           _log(dart.dindex(msg, 'msg'));
           break;
         case 'print':
-          if (_isolate_helper._globalState.isWorker) {
-            _isolate_helper._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'print', msg: msg})));
+          if (exports._globalState.isWorker) {
+            exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'print', msg: msg})));
           } else {
             core.print(dart.dindex(msg, 'msg'));
           }
           break;
         case 'error':
           throw dart.dindex(msg, 'msg');
       }
     }
     static handleSpawnWorkerRequest(msg) {
       let replyPort = dart.dindex(msg, 'replyPort');
       spawn(dart.as(dart.dindex(msg, 'functionName'), core.String), dart.as(dart.dindex(msg, 'uri'), core.String), dart.as(dart.dindex(msg, 'args'), core.List$(core.String)), dart.dindex(msg, 'msg'), false, dart.as(dart.dindex(msg, 'isSpawnUri'), core.bool), dart.as(dart.dindex(msg, 'startPaused'), core.bool)).then((msg) => {
         dart.dinvoke(replyPort, 'send', msg);
       }, {
         onError: (errorMessage) => {
           dart.dinvoke(replyPort, 'send', new List.from([_SPAWN_FAILED_SIGNAL, errorMessage]));
         }
       });
     }
     static _log(msg) {
-      if (_isolate_helper._globalState.isWorker) {
-        _isolate_helper._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'log', msg: msg})));
+      if (exports._globalState.isWorker) {
+        exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'log', msg: msg})));
       } else {
         try {
           _consoleLog(msg);
         } catch (e) {
           let trace = dart.stackTrace(e);
           throw new core.Exception(trace);
         }
 
       }
     }
@@ skipping 34 matching lines @@
       let completer = dart.as(new async.Completer(), async.Completer$(core.List));
       port.first.then(((msg) => {
         if (dart.equals(dart.dindex(msg, 0), _SPAWNED_SIGNAL)) {
           completer.complete(msg);
         } else {
           dart.assert(dart.equals(dart.dindex(msg, 0), _SPAWN_FAILED_SIGNAL));
           completer.completeError(dart.dindex(msg, 1));
         }
       }).bind(this));
       let signalReply = port.sendPort;
-      if (dart.notNull(_isolate_helper._globalState.useWorkers) && dart.notNull(!dart.notNull(isLight))) {
+      if (dart.notNull(exports._globalState.useWorkers) && dart.notNull(!dart.notNull(isLight))) {
         _startWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply, ((message) => completer.completeError(message)).bind(this));
       } else {
         _startNonWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply);
       }
       return completer.future;
     }
     static _startWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
       if (args !== null)
         args = new core.List.from(args);
-      if (_isolate_helper._globalState.isWorker) {
-        _isolate_helper._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'spawn-worker', functionName: functionName, args: args, msg: message, uri: uri, isSpawnUri: isSpawnUri, startPaused: startPaused, replyPort: replyPort})));
+      if (exports._globalState.isWorker) {
+        exports._globalState.mainManager.postMessage(_serializeMessage(dart.map({command: 'spawn-worker', functionName: functionName, args: args, msg: message, uri: uri, isSpawnUri: isSpawnUri, startPaused: startPaused, replyPort: replyPort})));
       } else {
         _spawnWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError);
       }
     }
     static _startNonWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort) {
       if (uri !== null) {
         throw new core.UnsupportedError("Currently spawnUri is not supported without web workers.");
       }
       message = _clone(message);
       if (args !== null)
         args = new core.List.from(args);
-      _isolate_helper._globalState.topEventLoop.enqueue(new _IsolateContext(), () => {
+      exports._globalState.topEventLoop.enqueue(new _IsolateContext(), () => {
         let func = _getJSFunctionFromName(functionName);
         _startIsolate(dart.as(func, core.Function), args, message, isSpawnUri, startPaused, replyPort);
       }, 'nonworker start');
     }
     static get currentIsolate() {
       let context = dart.as(_foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _IsolateContext);
       return new isolate.Isolate(context.controlPort.sendPort, {pauseCapability: context.pauseCapability, terminateCapability: context.terminateCapability});
     }
     static _startIsolate(topLevel, args, message, isSpawnUri, startPaused, replyTo) {
       let context = dart.as(_foreign_helper.JS_CURRENT_ISOLATE_CONTEXT(), _IsolateContext);
       _js_helper.Primitives.initializeStatics(context.id);
       replyTo.send(new List.from([_SPAWNED_SIGNAL, context.controlPort.sendPort, context.pauseCapability, context.terminateCapability]));
       // Function runStartFunction: () → void
       function runStartFunction() {
         context.initialized = true;
         if (!dart.notNull(isSpawnUri)) {
           dart.dinvokef(topLevel, message);
         } else if (dart.is(topLevel, _MainFunctionArgsMessage)) {
           dart.dinvokef(topLevel, args, message);
         } else if (dart.is(topLevel, _MainFunctionArgs)) {
           dart.dinvokef(topLevel, args);
         } else {
           dart.dinvokef(topLevel);
         }
       }
       if (startPaused) {
         context.addPause(context.pauseCapability, context.pauseCapability);
-        _isolate_helper._globalState.topEventLoop.enqueue(context, runStartFunction, 'start isolate');
+        exports._globalState.topEventLoop.enqueue(context, runStartFunction, 'start isolate');
       } else {
         runStartFunction();
       }
     }
     static _spawnWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
       if (uri === null)
         uri = thisScript;
       let worker = new Worker(uri);
       let onerrorTrampoline = function(f, u, c) {
         return function(e) {
           return f(e, u, c);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(workerOnError), uri, onError);
       worker.onerror = onerrorTrampoline;
       let processWorkerMessageTrampoline = function(f, a) {
         return function(e) {
           e.onerror = null;
           return f(a, e);
         };
       }(_foreign_helper.DART_CLOSURE_TO_JS(_processWorkerMessage), worker);
       worker.onmessage = processWorkerMessageTrampoline;
-      let workerId = _isolate_helper._globalState.nextManagerId++;
+      let workerId = exports._globalState.nextManagerId++;
       workerIds.set(worker, workerId);
-      _isolate_helper._globalState.managers.set(workerId, worker);
+      exports._globalState.managers.set(workerId, worker);
       worker.postMessage(_serializeMessage(dart.map({command: 'start', id: workerId, replyTo: _serializeMessage(replyPort), args: args, msg: _serializeMessage(message), isSpawnUri: isSpawnUri, startPaused: startPaused, functionName: functionName})));
     }
     static workerOnError(event, uri, onError) {
       event.preventDefault();
       let message = dart.as(event.message, core.String);
       if (message === null) {
         message = `Error spawning worker for ${uri}`;
       } else {
         message = `Error spawning worker for ${uri} (${message})`;
       }
@@ skipping 20 matching lines @@
         throw new core.Exception("SendPort.send: Illegal replyTo port type");
       }
     }
   }
   class _NativeJsSendPort extends _BaseSendPort {
     _NativeJsSendPort(_receivePort, isolateId) {
       this._receivePort = _receivePort;
       super._BaseSendPort(isolateId);
     }
     send(message) {
-      let isolate = _isolate_helper._globalState.isolates.get(this._isolateId);
+      let isolate = exports._globalState.isolates.get(this._isolateId);
       if (isolate === null)
         return;
       if (this._receivePort._isClosed)
         return;
       let msg = _clone(message);
       if (dart.equals(isolate.controlPort, this._receivePort)) {
         isolate.handleControlMessage(msg);
         return;
       }
-      _isolate_helper._globalState.topEventLoop.enqueue(isolate, (() => {
+      exports._globalState.topEventLoop.enqueue(isolate, (() => {
         if (!dart.notNull(this._receivePort._isClosed)) {
           this._receivePort._add(msg);
         }
       }).bind(this), `receive ${message}`);
     }
     ['=='](other) {
       return dart.notNull(dart.is(other, _NativeJsSendPort)) && dart.notNull(dart.equals(this._receivePort, dart.dload(other, '_receivePort')));
     }
     get hashCode() {
       return this._receivePort._id;
     }
   }
   class _WorkerSendPort extends _BaseSendPort {
     _WorkerSendPort(_workerId, isolateId, _receivePortId) {
       this._workerId = _workerId;
       this._receivePortId = _receivePortId;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let workerMessage = _serializeMessage(dart.map({command: 'message', port: this, msg: message}));
-      if (_isolate_helper._globalState.isWorker) {
-        _isolate_helper._globalState.mainManager.postMessage(workerMessage);
+      if (exports._globalState.isWorker) {
+        exports._globalState.mainManager.postMessage(workerMessage);
       } else {
-        let manager = _isolate_helper._globalState.managers.get(this._workerId);
+        let manager = exports._globalState.managers.get(this._workerId);
         if (manager !== null) {
           manager.postMessage(workerMessage);
         }
       }
     }
     ['=='](other) {
       return dart.notNull(dart.notNull(dart.notNull(dart.is(other, _WorkerSendPort)) && dart.notNull(this._workerId === dart.dload(other, '_workerId'))) && dart.notNull(this._isolateId === dart.dload(other, '_isolateId'))) && dart.notNull(this._receivePortId === dart.dload(other, '_receivePortId'));
     }
     get hashCode() {
       return this._workerId << 16 ^ this._isolateId << 8 ^ this._receivePortId;
     }
   }
   class RawReceivePortImpl extends dart.Object {
     RawReceivePortImpl(_handler) {
       this._handler = _handler;
       this._id = _nextFreeId++;
       this._isClosed = false;
-      _isolate_helper._globalState.currentContext.register(this._id, this);
+      exports._globalState.currentContext.register(this._id, this);
     }
     RawReceivePortImpl$weak(_handler) {
       this._handler = _handler;
       this._id = _nextFreeId++;
       this._isClosed = false;
-      _isolate_helper._globalState.currentContext.registerWeak(this._id, this);
+      exports._globalState.currentContext.registerWeak(this._id, this);
     }
     RawReceivePortImpl$_controlPort() {
       this._handler = null;
       this._id = 0;
       this._isClosed = false;
     }
     set handler(newHandler) {
       this._handler = newHandler;
     }
     _close() {
       this._isClosed = true;
       this._handler = null;
     }
     close() {
       if (this._isClosed)
         return;
       this._isClosed = true;
       this._handler = null;
-      _isolate_helper._globalState.currentContext.unregister(this._id);
+      exports._globalState.currentContext.unregister(this._id);
     }
     _add(dataEvent) {
       if (this._isClosed)
         return;
       dart.dinvokef(this._handler, dataEvent);
     }
     get sendPort() {
-      return new _NativeJsSendPort(this, _isolate_helper._globalState.currentContext.id);
+      return new _NativeJsSendPort(this, exports._globalState.currentContext.id);
     }
   }
   dart.defineNamedConstructor(RawReceivePortImpl, 'weak');
   dart.defineNamedConstructor(RawReceivePortImpl, '_controlPort');
   RawReceivePortImpl._nextFreeId = 1;
   class ReceivePortImpl extends async.Stream {
     ReceivePortImpl() {
       this.ReceivePortImpl$fromRawReceivePort(new RawReceivePortImpl(null));
     }
     ReceivePortImpl$weak() {
@@ skipping 20 matching lines @@
       return this._rawPort.sendPort;
     }
   }
   dart.defineNamedConstructor(ReceivePortImpl, 'weak');
   dart.defineNamedConstructor(ReceivePortImpl, 'fromRawReceivePort');
   class TimerImpl extends dart.Object {
     TimerImpl(milliseconds, callback) {
       this._once = true;
       this._inEventLoop = false;
       this._handle = dart.as(null, core.int);
-      if (dart.notNull(milliseconds === 0) && dart.notNull(dart.notNull(!dart.notNull(hasTimer())) || dart.notNull(_isolate_helper._globalState.isWorker))) {
+      if (dart.notNull(milliseconds === 0) && dart.notNull(dart.notNull(!dart.notNull(hasTimer())) || dart.notNull(exports._globalState.isWorker))) {
         // Function internalCallback: () → void
         function internalCallback() {
           this._handle = dart.as(null, core.int);
           callback();
         }
         this._handle = 1;
-        _isolate_helper._globalState.topEventLoop.enqueue(_isolate_helper._globalState.currentContext, internalCallback, 'timer');
+        exports._globalState.topEventLoop.enqueue(exports._globalState.currentContext, internalCallback, 'timer');
         this._inEventLoop = true;
       } else if (hasTimer()) {
         // Function internalCallback: () → void
         function internalCallback() {
           this._handle = dart.as(null, core.int);
           leaveJsAsync();
           callback();
         }
         enterJsAsync();
         this._handle = self.setTimeout(_js_helper.convertDartClosureToJS(internalCallback, 0), milliseconds);
@@ skipping 189 matching lines @@
       return new List.from(['js-object', keys, values]);
     }
     serializeWorkerSendPort(x) {
       if (this._serializeSendPorts) {
         return new List.from(['sendport', x._workerId, x._isolateId, x._receivePortId]);
       }
       return new List.from(['raw sendport', x]);
     }
     serializeJsSendPort(x) {
       if (this._serializeSendPorts) {
-        let workerId = _isolate_helper._globalState.currentManagerId;
+        let workerId = exports._globalState.currentManagerId;
         return new List.from(['sendport', workerId, x._isolateId, x._receivePort._id]);
       }
       return new List.from(['raw sendport', x]);
     }
     serializeCapability(x) {
       return new List.from(['capability', x._id]);
     }
     serializeClosure(x) {
       let name = IsolateNatives._getJSFunctionName(x);
       if (name === null) {
@@ skipping 115 matching lines @@
         result.set(keys.get(i), this.deserialize(values.get(i)));
       }
       return result;
     }
     deserializeSendPort(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'sendport'));
       let managerId = dart.as(dart.dindex(x, 1), core.int);
       let isolateId = dart.as(dart.dindex(x, 2), core.int);
       let receivePortId = dart.as(dart.dindex(x, 3), core.int);
       let result = null;
-      if (managerId === _isolate_helper._globalState.currentManagerId) {
-        let isolate = _isolate_helper._globalState.isolates.get(isolateId);
+      if (managerId === exports._globalState.currentManagerId) {
+        let isolate = exports._globalState.isolates.get(isolateId);
         if (isolate === null)
           return null;
         let receivePort = isolate.lookup(receivePortId);
         if (receivePort === null)
           return null;
         result = new _NativeJsSendPort(receivePort, isolateId);
       } else {
         result = new _WorkerSendPort(managerId, isolateId, receivePortId);
       }
       this.deserializedObjects.add(result);
@@ skipping 29 matching lines @@
       let fields = dart.as(dart.dindex(x, 2), core.List);
       let instanceFromClassId = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.INSTANCE_FROM_CLASS_ID, core.String));
       let initializeObject = _foreign_helper.JS_EMBEDDED_GLOBAL('', dart.as(_js_embedded_names.INITIALIZE_EMPTY_INSTANCE, core.String));
       let emptyInstance = instanceFromClassId(classId);
       this.deserializedObjects.add(emptyInstance);
       this.deserializeArrayInPlace(dart.as(fields, _interceptors.JSArray));
       return initializeObject(classId, emptyInstance, fields);
     }
   }
   // Exports:
-  _isolate_helper.enterJsAsync = enterJsAsync;
-  _isolate_helper.leaveJsAsync = leaveJsAsync;
-  _isolate_helper.isWorker = isWorker;
-  _isolate_helper.startRootIsolate = startRootIsolate;
-  _isolate_helper.globalWindow = globalWindow;
-  _isolate_helper.globalWorker = globalWorker;
-  _isolate_helper.globalPostMessageDefined = globalPostMessageDefined;
-  _isolate_helper.IsolateNatives = IsolateNatives;
-  _isolate_helper.RawReceivePortImpl = RawReceivePortImpl;
-  _isolate_helper.ReceivePortImpl = ReceivePortImpl;
-  _isolate_helper.TimerImpl = TimerImpl;
-  _isolate_helper.hasTimer = hasTimer;
-  _isolate_helper.CapabilityImpl = CapabilityImpl;
+  exports.enterJsAsync = enterJsAsync;
+  exports.leaveJsAsync = leaveJsAsync;
+  exports.isWorker = isWorker;
+  exports.startRootIsolate = startRootIsolate;
+  exports.globalWindow = globalWindow;
+  exports.globalWorker = globalWorker;
+  exports.globalPostMessageDefined = globalPostMessageDefined;
+  exports.IsolateNatives = IsolateNatives;
+  exports.RawReceivePortImpl = RawReceivePortImpl;
+  exports.ReceivePortImpl = ReceivePortImpl;
+  exports.TimerImpl = TimerImpl;
+  exports.hasTimer = hasTimer;
+  exports.CapabilityImpl = CapabilityImpl;
 })(_isolate_helper || (_isolate_helper = {}));