Delete dart2js specific private library code

lib/runtime/dart/_isolate_helper.js

 var _isolate_helper = dart.defineLibrary(_isolate_helper, {});
 var core = dart.import(core);
 var _native_typed_data = dart.import(_native_typed_data);
-var _interceptors = dart.lazyImport(_interceptors);
-var _js_helper = dart.lazyImport(_js_helper);
+var _interceptors = dart.import(_interceptors);
+var _js_helper = dart.import(_js_helper);
 var isolate = dart.import(isolate);
 var _foreign_helper = dart.import(_foreign_helper);
 var _js_embedded_names = dart.import(_js_embedded_names);
 var collection = dart.import(collection);
 var async = dart.import(async);
 (function(exports, core, _native_typed_data, _interceptors, _js_helper, isolate, _foreign_helper, _js_embedded_names, collection, async) {
   'use strict';
   function _serializeMessage(message) {
     return new _Serializer().serialize(message);
   }
@@ skipping 40 matching lines @@
         return this.serializeJSObject(dart.as(x, _interceptors.JSObject));
       if (dart.is(x, _interceptors.Interceptor))
         this.unsupported(x);
       if (dart.is(x, isolate.RawReceivePort)) {
         this.unsupported(x, "RawReceivePorts can't be transmitted:");
       }
       if (dart.is(x, _NativeJsSendPort))
         return this.serializeJsSendPort(dart.as(x, _NativeJsSendPort));
       if (dart.is(x, _WorkerSendPort))
         return this.serializeWorkerSendPort(dart.as(x, _WorkerSendPort));
-      if (dart.is(x, _js_helper.Closure))
-        return this.serializeClosure(dart.as(x, _js_helper.Closure));
+      if (dart.is(x, core.Function))
+        return this.serializeClosure(dart.as(x, core.Function));
       return this.serializeDartObject(x);
     }
     unsupported(x, message) {
       if (message === void 0)
         message = null;
       if (message == null)
         message = "Can't transmit:";
       throw new core.UnsupportedError(`${message} ${x}`);
     }
     makeRef(serializationId) {
@@ skipping 97 matching lines @@
       serializeByteBuffer: [core.Object, [_native_typed_data.NativeByteBuffer]],
       serializeTypedData: [core.Object, [_native_typed_data.NativeTypedData]],
       serializeJSIndexable: [core.Object, [_interceptors.JSIndexable]],
       serializeArray: [core.Object, [_interceptors.JSArray]],
       serializeArrayInPlace: [core.Object, [_interceptors.JSArray]],
       serializeMap: [core.Object, [core.Map]],
       serializeJSObject: [core.Object, [_interceptors.JSObject]],
       serializeWorkerSendPort: [core.Object, [_WorkerSendPort]],
       serializeJsSendPort: [core.Object, [_NativeJsSendPort]],
       serializeCapability: [core.Object, [CapabilityImpl]],
-      serializeClosure: [core.Object, [_js_helper.Closure]],
+      serializeClosure: [core.Object, [core.Function]],
       serializeDartObject: [core.Object, [core.Object]]
     })
   });
   let _adjustSendPorts = Symbol('_adjustSendPorts');
   class _Deserializer extends core.Object {
     _Deserializer(opts) {
       let adjustSendPorts = opts && 'adjustSendPorts' in opts ? opts.adjustSendPorts : true;
       this.deserializedObjects = core.List.new();
       this[_adjustSendPorts] = dart.as(adjustSendPorts, core.bool);
     }
@@ skipping 712 matching lines @@
       }
       this.isolate.eval(this.fn);
     }
   }
   dart.setSignature(_IsolateEvent, {
     constructors: () => ({_IsolateEvent: [_IsolateEvent, [_IsolateContext, core.Function, core.String]]}),
     methods: () => ({process: [dart.void, []]})
   });
   class _MainManagerStub extends core.Object {
     postMessage(msg) {
-      _js_helper.requiresPreamble();
       self.postMessage(msg);
     }
   }
   dart.setSignature(_MainManagerStub, {
     methods: () => ({postMessage: [dart.void, [core.Object]]})
   });
   let _SPAWNED_SIGNAL = "spawned";
   let _SPAWN_FAILED_SIGNAL = "spawn failed";
   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;
     }
   });
   let _MainFunction = dart.typedef('_MainFunction', () => dart.functionType(core.Object, []));
   let _MainFunctionArgs = dart.typedef('_MainFunctionArgs', () => dart.functionType(core.Object, [dart.bottom]));
   let _MainFunctionArgsMessage = dart.typedef('_MainFunctionArgsMessage', () => dart.functionType(core.Object, [dart.bottom, dart.bottom]));
   class IsolateNatives extends core.Object {
     static computeThisScript() {
       let currentScript = document.currentScript;
       if (currentScript != null) {
@@ skipping 119 matching lines @@
         try {
           IsolateNatives._consoleLog(msg);
         } catch (e) {
           let trace = dart.stackTrace(e);
           throw core.Exception.new(trace);
         }
 
       }
     }
     static _consoleLog(msg) {
-      _js_helper.requiresPreamble();
       self.console.log(msg);
     }
     static _getJSFunctionFromName(functionName) {
       let globalFunctionsContainer = _foreign_helper.JS_EMBEDDED_GLOBAL("", _js_embedded_names.GLOBAL_FUNCTIONS);
       return globalFunctionsContainer[functionName]();
     }
     static _getJSFunctionName(f) {
-      return dart.is(f, _js_helper.Closure) ? dart.as(f.$name, core.String) : null;
+      return dart.as(f.$name, core.String);
     }
     static _allocate(ctor) {
       return new ctor();
     }
     static spawnFunction(topLevelFunction, message, startPaused) {
       IsolateNatives.enableSpawnWorker = true;
       let name = IsolateNatives._getJSFunctionName(topLevelFunction);
       if (name == null) {
         throw new core.UnsupportedError("only top-level functions can be spawned.");
       }
@@ skipping 409 matching lines @@
   TimerImpl[dart.implements] = () => [async.Timer];
   dart.defineNamedConstructor(TimerImpl, 'periodic');
   dart.setSignature(TimerImpl, {
     constructors: () => ({
       TimerImpl: [TimerImpl, [core.int, dart.functionType(dart.void, [])]],
       periodic: [TimerImpl, [core.int, dart.functionType(dart.void, [async.Timer])]]
     }),
     methods: () => ({cancel: [dart.void, []]})
   });
   function hasTimer() {
-    _js_helper.requiresPreamble();
     return self.setTimeout != null;
   }
   dart.fn(hasTimer, core.bool, []);
   class CapabilityImpl extends core.Object {
     CapabilityImpl() {
       this._internal(_js_helper.random64());
     }
     _internal(id) {
       this[_id] = id;
     }
@@ skipping 31 matching lines @@
   exports.leaveJsAsync = leaveJsAsync;
   exports.isWorker = isWorker;
   exports.startRootIsolate = startRootIsolate;
   exports.IsolateNatives = IsolateNatives;
   exports.RawReceivePortImpl = RawReceivePortImpl;
   exports.ReceivePortImpl = ReceivePortImpl;
   exports.TimerImpl = TimerImpl;
   exports.hasTimer = hasTimer;
   exports.CapabilityImpl = CapabilityImpl;
 })(_isolate_helper, core, _native_typed_data, _interceptors, _js_helper, isolate, _foreign_helper, _js_embedded_names, collection, async);