JS: Format if statements with no else on a single line

lib/runtime/dart/_isolate_helper.js

 dart_library.library('dart/_isolate_helper', null, /* Imports */[
   "dart/_runtime",
   'dart/core',
   'dart/_interceptors',
   'dart/_js_helper',
   'dart/isolate',
   'dart/_foreign_helper',
   'dart/collection',
   'dart/async'
 ], /* Lazy imports */[
@@ skipping 22 matching lines @@
   const _receivePortId = Symbol('_receivePortId');
   const _id = Symbol('_id');
   const _receivePort = Symbol('_receivePort');
   class _Serializer extends core.Object {
     _Serializer(opts) {
       let serializeSendPorts = opts && 'serializeSendPorts' in opts ? opts.serializeSendPorts : true;
       this.serializedObjectIds = core.Map$(dart.dynamic, core.int).identity();
       this[_serializeSendPorts] = dart.as(serializeSendPorts, core.bool);
     }
     serialize(x) {
-      if (dart.notNull(this.isPrimitive(x)))
-        return this.serializePrimitive(x);
+      if (dart.notNull(this.isPrimitive(x))) return this.serializePrimitive(x);
       let serializationId = this.serializedObjectIds.get(x);
-      if (serializationId != null)
-        return this.makeRef(serializationId);
+      if (serializationId != null) return this.makeRef(serializationId);
       serializationId = this.serializedObjectIds.length;
       this.serializedObjectIds.set(x, serializationId);
-      if (dart.is(x, _native_typed_data.NativeByteBuffer))
-        return this.serializeByteBuffer(dart.as(x, _native_typed_data.NativeByteBuffer));
-      if (dart.is(x, _native_typed_data.NativeTypedData))
-        return this.serializeTypedData(dart.as(x, _native_typed_data.NativeTypedData));
-      if (dart.is(x, _interceptors.JSIndexable))
-        return this.serializeJSIndexable(dart.as(x, _interceptors.JSIndexable));
-      if (dart.is(x, _js_helper.InternalMap))
-        return this.serializeMap(dart.as(x, core.Map));
-      if (dart.is(x, _interceptors.JSObject))
-        return this.serializeJSObject(dart.as(x, _interceptors.JSObject));
-      if (dart.is(x, _interceptors.Interceptor))
-        this.unsupported(x);
+      if (dart.is(x, _native_typed_data.NativeByteBuffer)) return this.serializeByteBuffer(dart.as(x, _native_typed_data.NativeByteBuffer));
+      if (dart.is(x, _native_typed_data.NativeTypedData)) return this.serializeTypedData(dart.as(x, _native_typed_data.NativeTypedData));
+      if (dart.is(x, _interceptors.JSIndexable)) return this.serializeJSIndexable(dart.as(x, _interceptors.JSIndexable));
+      if (dart.is(x, _js_helper.InternalMap)) return this.serializeMap(dart.as(x, core.Map));
+      if (dart.is(x, _interceptors.JSObject)) 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, core.Function))
-        return this.serializeClosure(dart.as(x, core.Function));
+      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, 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:";
+      if (message === void 0) message = null;
+      if (message == null) message = "Can't transmit:";
       dart.throw(new core.UnsupportedError(`${message} ${x}`));
     }
     makeRef(serializationId) {
       return ["ref", serializationId];
     }
     isPrimitive(x) {
       return x == null || typeof x == 'string' || typeof x == 'number' || typeof x == 'boolean';
     }
     serializePrimitive(primitive) {
       return primitive;
     }
     serializeByteBuffer(buffer) {
       return ["buffer", buffer];
     }
     serializeTypedData(data) {
       return ["typed", data];
     }
     serializeJSIndexable(indexable) {
       dart.assert(!(typeof indexable == 'string'));
       let serialized = dart.as(this.serializeArray(dart.as(indexable, _interceptors.JSArray)), core.List);
-      if (dart.is(indexable, _interceptors.JSFixedArray))
-        return ["fixed", serialized];
-      if (dart.is(indexable, _interceptors.JSExtendableArray))
-        return ["extendable", serialized];
-      if (dart.is(indexable, _interceptors.JSMutableArray))
-        return ["mutable", serialized];
-      if (dart.is(indexable, _interceptors.JSArray))
-        return ["const", serialized];
+      if (dart.is(indexable, _interceptors.JSFixedArray)) return ["fixed", serialized];
+      if (dart.is(indexable, _interceptors.JSExtendableArray)) return ["extendable", serialized];
+      if (dart.is(indexable, _interceptors.JSMutableArray)) return ["mutable", serialized];
+      if (dart.is(indexable, _interceptors.JSArray)) return ["const", serialized];
       this.unsupported(indexable, "Can't serialize indexable: ");
       return null;
     }
     serializeArray(x) {
       let serialized = [];
       serialized[dartx.length] = x[dartx.length];
       for (let i = 0; dart.notNull(i) < dart.notNull(x[dartx.length]); i = dart.notNull(i) + 1) {
         serialized[dartx.set](i, this.serialize(x[dartx.get](i)));
       }
       return serialized;
@@ skipping 74 matching lines @@
     })
   });
   const _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);
     }
     deserialize(x) {
-      if (dart.notNull(this.isPrimitive(x)))
-        return this.deserializePrimitive(x);
-      if (!dart.is(x, _interceptors.JSArray))
-        dart.throw(new core.ArgumentError(`Bad serialized message: ${x}`));
+      if (dart.notNull(this.isPrimitive(x))) return this.deserializePrimitive(x);
+      if (!dart.is(x, _interceptors.JSArray)) dart.throw(new core.ArgumentError(`Bad serialized message: ${x}`));
       switch (dart.dload(x, 'first')) {
         case "ref":
         {
           return this.deserializeRef(x);
         }
         case "buffer":
         {
           return this.deserializeByteBuffer(x);
         }
         case "typed":
@@ skipping 112 matching lines @@
       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 == exports._globalState.currentManagerId) {
         let isolate = exports._globalState.isolates.get(isolateId);
-        if (isolate == null)
-          return null;
+        if (isolate == null) return null;
         let receivePort = isolate.lookup(receivePortId);
-        if (receivePort == null)
-          return null;
+        if (receivePort == null) return null;
         result = new _NativeJsSendPort(receivePort, isolateId);
       } else {
         result = new _WorkerSendPort(managerId, isolateId, receivePortId);
       }
       this.deserializedObjects[dartx.add](result);
       return result;
     }
     deserializeRawSendPort(x) {
       dart.assert(dart.equals(dart.dindex(x, 0), 'raw sendport'));
       let result = dart.as(dart.dindex(x, 1), isolate.SendPort);
@@ skipping 74 matching lines @@
   function isWorker() {
     return exports._globalState.isWorker;
   }
   dart.fn(isWorker, core.bool, []);
   function _currentIsolate() {
     return exports._globalState.currentContext;
   }
   dart.fn(_currentIsolate, () => dart.definiteFunctionType(_IsolateContext, []));
   function startRootIsolate(entry, args) {
     args = args;
-    if (args == null)
-      args = [];
+    if (args == null) args = [];
     if (!dart.is(args, core.List)) {
       dart.throw(new core.ArgumentError(`Arguments to main must be a List: ${args}`));
     }
     exports._globalState = new _Manager(dart.as(entry, core.Function));
-    if (dart.notNull(exports._globalState.isWorker))
-      return;
+    if (dart.notNull(exports._globalState.isWorker)) return;
     let rootContext = new _IsolateContext();
     exports._globalState.rootContext = rootContext;
     exports._globalState.currentContext = rootContext;
     if (dart.is(entry, _MainFunctionArgs)) {
       rootContext.eval(dart.fn(() => {
         dart.dcall(entry, args);
       }));
     } else if (dart.is(entry, _MainFunctionArgsMessage)) {
       rootContext.eval(dart.fn(() => {
         dart.dcall(entry, args, null);
@@ skipping 108 matching lines @@
       this.errorPorts = core.Set$(isolate.SendPort).new();
       this.initialized = false;
       this.isPaused = false;
       this.doneHandlers = null;
       this[_scheduledControlEvents] = null;
       this[_isExecutingEvent] = false;
       this.errorsAreFatal = true;
       this.registerWeak(this.controlPort[_id], this.controlPort);
     }
     addPause(authentification, resume) {
-      if (!dart.equals(this.pauseCapability, authentification))
-        return;
+      if (!dart.equals(this.pauseCapability, authentification)) return;
       if (dart.notNull(this.pauseTokens.add(resume)) && !dart.notNull(this.isPaused)) {
         this.isPaused = true;
       }
       this[_updateGlobalState]();
     }
     removePause(resume) {
-      if (!dart.notNull(this.isPaused))
-        return;
+      if (!dart.notNull(this.isPaused)) return;
       this.pauseTokens.remove(resume);
       if (dart.notNull(this.pauseTokens.isEmpty)) {
         while (dart.notNull(this.delayedEvents[dartx.isNotEmpty])) {
           let event = this.delayedEvents[dartx.removeLast]();
           exports._globalState.topEventLoop.prequeue(event);
         }
         this.isPaused = false;
       }
       this[_updateGlobalState]();
     }
     addDoneListener(responsePort) {
       if (this.doneHandlers == null) {
         this.doneHandlers = [];
       }
-      if (dart.notNull(dart.as(dart.dsend(this.doneHandlers, 'contains', responsePort), core.bool)))
-        return;
+      if (dart.notNull(dart.as(dart.dsend(this.doneHandlers, 'contains', responsePort), core.bool))) return;
       dart.dsend(this.doneHandlers, 'add', responsePort);
     }
     removeDoneListener(responsePort) {
-      if (this.doneHandlers == null)
-        return;
+      if (this.doneHandlers == null) return;
       dart.dsend(this.doneHandlers, 'remove', responsePort);
     }
     setErrorsFatal(authentification, errorsAreFatal) {
-      if (!dart.equals(this.terminateCapability, authentification))
-        return;
+      if (!dart.equals(this.terminateCapability, authentification)) return;
       this.errorsAreFatal = errorsAreFatal;
     }
     handlePing(responsePort, pingType) {
       if (pingType == isolate.Isolate.IMMEDIATE || pingType == isolate.Isolate.BEFORE_NEXT_EVENT && !dart.notNull(this[_isExecutingEvent])) {
         responsePort.send(null);
         return;
       }
       function respond() {
         responsePort.send(null);
       }
       dart.fn(respond, dart.void, []);
       if (pingType == isolate.Isolate.AS_EVENT) {
         exports._globalState.topEventLoop.enqueue(this, respond, "ping");
         return;
       }
       dart.assert(pingType == isolate.Isolate.BEFORE_NEXT_EVENT);
       if (this[_scheduledControlEvents] == null) {
         this[_scheduledControlEvents] = collection.Queue.new();
       }
       dart.dsend(this[_scheduledControlEvents], 'addLast', respond);
     }
     handleKill(authentification, priority) {
-      if (!dart.equals(this.terminateCapability, authentification))
-        return;
+      if (!dart.equals(this.terminateCapability, authentification)) return;
       if (priority == isolate.Isolate.IMMEDIATE || priority == isolate.Isolate.BEFORE_NEXT_EVENT && !dart.notNull(this[_isExecutingEvent])) {
         this.kill();
         return;
       }
       if (priority == isolate.Isolate.AS_EVENT) {
         exports._globalState.topEventLoop.enqueue(this, dart.bind(this, 'kill'), "kill");
         return;
       }
       dart.assert(priority == isolate.Isolate.BEFORE_NEXT_EVENT);
       if (this[_scheduledControlEvents] == null) {
         this[_scheduledControlEvents] = collection.Queue.new();
       }
       dart.dsend(this[_scheduledControlEvents], 'addLast', dart.bind(this, 'kill'));
     }
     addErrorListener(port) {
       this.errorPorts.add(port);
     }
     removeErrorListener(port) {
       this.errorPorts.remove(port);
     }
     handleUncaughtError(error, stackTrace) {
       if (dart.notNull(this.errorPorts.isEmpty)) {
         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);
+          if (stackTrace != null) core.print(stackTrace);
         }
         return;
       }
       let message = core.List.new(2);
       message[dartx.set](0, dart.toString(error));
       message[dartx.set](1, stackTrace == null ? null : dart.toString(stackTrace));
       for (let port of this.errorPorts)
         port.send(message);
     }
     eval(code) {
@@ skipping 10 matching lines @@
         if (dart.notNull(this.errorsAreFatal)) {
           this.kill();
           if (dart.notNull(core.identical(this, exports._globalState.rootContext))) {
             throw e;
           }
         }
       }
  finally {
         this[_isExecutingEvent] = false;
         exports._globalState.currentContext = old;
-        if (old != null)
-          old[_setGlobals]();
+        if (old != null) old[_setGlobals]();
         if (this[_scheduledControlEvents] != null) {
           while (dart.notNull(dart.as(dart.dload(this[_scheduledControlEvents], 'isNotEmpty'), core.bool))) {
             dart.dcall(dart.dsend(this[_scheduledControlEvents], 'removeFirst'));
           }
         }
       }
       return result;
     }
     [_setGlobals]() {
       _foreign_helper.JS_SET_CURRENT_ISOLATE(this.isolateStatics);
@@ skipping 128 matching lines @@
       this.events = collection.Queue$(_IsolateEvent).new();
       this[_activeJsAsyncCount] = 0;
     }
     enqueue(isolate, fn, msg) {
       this.events.addLast(new _IsolateEvent(dart.as(isolate, _IsolateContext), dart.as(fn, core.Function), dart.as(msg, core.String)));
     }
     prequeue(event) {
       this.events.addFirst(event);
     }
     dequeue() {
-      if (dart.notNull(this.events.isEmpty))
-        return null;
+      if (dart.notNull(this.events.isEmpty)) return null;
       return this.events.removeFirst();
     }
     checkOpenReceivePortsFromCommandLine() {
       if (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)) {
         dart.throw(core.Exception.new("Program exited with open ReceivePorts."));
       }
     }
     runIteration() {
       let event = this.dequeue();
       if (event == null) {
         this.checkOpenReceivePortsFromCommandLine();
         exports._globalState.maybeCloseWorker();
         return false;
       }
       event.process();
       return true;
     }
     [_runHelper]() {
       if (exports.globalWindow != null) {
         const next = (function() {
-          if (!dart.notNull(this.runIteration()))
-            return;
+          if (!dart.notNull(this.runIteration())) return;
           async.Timer.run(next);
         }).bind(this);
         dart.fn(next);
         next();
       } else {
         while (dart.notNull(this.runIteration())) {
         }
       }
     }
     run() {
@@ skipping 64 matching lines @@
   });
   const _MainFunction = dart.typedef('_MainFunction', () => dart.functionType(dart.dynamic, []));
   const _MainFunctionArgs = dart.typedef('_MainFunctionArgs', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   const _MainFunctionArgsMessage = dart.typedef('_MainFunctionArgsMessage', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   class IsolateNatives extends core.Object {
     static computeThisScript() {
       let currentScript = document.currentScript;
       if (currentScript != null) {
         return String(currentScript.src);
       }
-      if (dart.notNull(_js_helper.Primitives.isD8))
-        return IsolateNatives.computeThisScriptD8();
-      if (dart.notNull(_js_helper.Primitives.isJsshell))
-        return IsolateNatives.computeThisScriptJsshell();
+      if (dart.notNull(_js_helper.Primitives.isD8)) return IsolateNatives.computeThisScriptD8();
+      if (dart.notNull(_js_helper.Primitives.isJsshell)) return IsolateNatives.computeThisScriptJsshell();
       if (exports._globalState != null && dart.notNull(exports._globalState.isWorker)) {
         return IsolateNatives.computeThisScriptFromTrace();
       }
       return null;
     }
     static computeThisScriptJsshell() {
       return dart.as(thisFilename(), core.String);
     }
     static computeThisScriptD8() {
       return IsolateNatives.computeThisScriptFromTrace();
     }
     static computeThisScriptFromTrace() {
       let stack = new Error().stack;
       if (stack == null) {
         stack = (function() {
           try {
             throw new Error();
           } catch (e) {
             return e.stack;
           }
 
         })();
-        if (stack == null)
-          dart.throw(new core.UnsupportedError('No stack trace'));
+        if (stack == null) dart.throw(new core.UnsupportedError('No stack trace'));
       }
       let pattern = null, matches = null;
       pattern = new RegExp("^ *at [^(]*\\((.*):[0-9]*:[0-9]*\\)$", "m");
       matches = stack.match(pattern);
-      if (matches != null)
-        return matches[1];
+      if (matches != null) return matches[1];
       pattern = new RegExp("^[^@]*@(.*):[0-9]*$", "m");
       matches = stack.match(pattern);
-      if (matches != null)
-        return matches[1];
+      if (matches != null) return matches[1];
       dart.throw(new core.UnsupportedError(`Cannot extract URI from "${stack}"`));
     }
     static _getEventData(e) {
       return e.data;
     }
     static _processWorkerMessage(sender, e) {
       let msg = _deserializeMessage(IsolateNatives._getEventData(e));
       switch (dart.dindex(msg, 'command')) {
         case 'start':
         {
           exports._globalState.currentManagerId = dart.as(dart.dindex(msg, 'id'), core.int);
           let functionName = dart.as(dart.dindex(msg, 'functionName'), core.String);
           let entryPoint = functionName == null ? exports._globalState.entry : dart.as(IsolateNatives._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();
           exports._globalState.topEventLoop.enqueue(context, dart.fn(() => {
             IsolateNatives._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');
           exports._globalState.currentContext = context;
           exports._globalState.topEventLoop.run();
           break;
         }
         case 'spawn-worker':
         {
-          if (IsolateNatives.enableSpawnWorker != null)
-            IsolateNatives.handleSpawnWorkerRequest(msg);
+          if (IsolateNatives.enableSpawnWorker != null) IsolateNatives.handleSpawnWorkerRequest(msg);
           break;
         }
         case 'message':
         {
           let port = dart.as(dart.dindex(msg, 'port'), isolate.SendPort);
           if (port != null) {
             dart.dsend(dart.dindex(msg, 'port'), 'send', dart.dindex(msg, 'msg'));
           }
           exports._globalState.topEventLoop.run();
           break;
@@ skipping 91 matching lines @@
       }));
       let signalReply = port.sendPort;
       if (dart.notNull(exports._globalState.useWorkers) && !dart.notNull(isLight)) {
         IsolateNatives._startWorker(functionName, uri, args, message, isSpawnUri, startPaused, signalReply, dart.fn(message => completer.completeError(message), dart.void, [core.String]));
       } else {
         IsolateNatives._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 = core.List$(core.String).from(args);
+      if (args != null) args = core.List$(core.String).from(args);
       if (dart.notNull(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 {
         IsolateNatives._spawnWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError);
       }
     }
     static _startNonWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort) {
       if (uri != null) {
         dart.throw(new core.UnsupportedError("Currently spawnUri is not supported without web workers."));
       }
       message = _clone(message);
-      if (args != null)
-        args = core.List$(core.String).from(args);
+      if (args != null) args = core.List$(core.String).from(args);
       exports._globalState.topEventLoop.enqueue(new _IsolateContext(), dart.fn(() => {
         let func = IsolateNatives._getJSFunctionFromName(functionName);
         IsolateNatives._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) {
@@ skipping 14 matching lines @@
       }
       dart.fn(runStartFunction, dart.void, []);
       if (dart.notNull(startPaused)) {
         context.addPause(context.pauseCapability, context.pauseCapability);
         exports._globalState.topEventLoop.enqueue(context, runStartFunction, 'start isolate');
       } else {
         runStartFunction();
       }
     }
     static _spawnWorker(functionName, uri, args, message, isSpawnUri, startPaused, replyPort, onError) {
-      if (uri == null)
-        uri = IsolateNatives.thisScript;
+      if (uri == null) uri = IsolateNatives.thisScript;
       let worker = new Worker(uri);
       let onerrorTrampoline = (function(f, u, c) {
         return function(e) {
           return f(e, u, c);
         };
       })(IsolateNatives.workerOnError, uri, onError);
       worker.onerror = onerrorTrampoline;
       let processWorkerMessageTrampoline = (function(f, a) {
         return function(e) {
           e.onerror = null;
@@ skipping 73 matching lines @@
   });
   const _isClosed = Symbol('_isClosed');
   const _add = Symbol('_add');
   class _NativeJsSendPort extends _BaseSendPort {
     _NativeJsSendPort(receivePort, isolateId) {
       this[_receivePort] = receivePort;
       super._BaseSendPort(isolateId);
     }
     send(message) {
       let isolate = exports._globalState.isolates.get(this[_isolateId]);
-      if (isolate == null)
-        return;
-      if (dart.notNull(this[_receivePort][_isClosed]))
-        return;
+      if (isolate == null) return;
+      if (dart.notNull(this[_receivePort][_isClosed])) return;
       let msg = _clone(message);
       if (dart.equals(isolate.controlPort, this[_receivePort])) {
         isolate.handleControlMessage(msg);
         return;
       }
       exports._globalState.topEventLoop.enqueue(isolate, dart.fn((() => {
         if (!dart.notNull(this[_receivePort][_isClosed])) {
           this[_receivePort][_add](msg);
         }
       }).bind(this)), `receive ${message}`);
@@ skipping 67 matching lines @@
       this[_isClosed] = false;
     }
     set handler(newHandler) {
       this[_handler] = newHandler;
     }
     [_close]() {
       this[_isClosed] = true;
       this[_handler] = null;
     }
     close() {
-      if (dart.notNull(this[_isClosed]))
-        return;
+      if (dart.notNull(this[_isClosed])) return;
       this[_isClosed] = true;
       this[_handler] = null;
       exports._globalState.currentContext.unregister(this[_id]);
     }
     [_add](dataEvent) {
-      if (dart.notNull(this[_isClosed]))
-        return;
+      if (dart.notNull(this[_isClosed])) return;
       dart.dcall(this[_handler], dataEvent);
     }
     get sendPort() {
       return new _NativeJsSendPort(this, exports._globalState.currentContext.id);
     }
   }
   RawReceivePortImpl[dart.implements] = () => [isolate.RawReceivePort];
   dart.defineNamedConstructor(RawReceivePortImpl, 'weak');
   dart.defineNamedConstructor(RawReceivePortImpl, '_controlPort');
   dart.setSignature(RawReceivePortImpl, {
@@ skipping 95 matching lines @@
         }).bind(this)), milliseconds);
       } else {
         dart.throw(new core.UnsupportedError("Periodic timer."));
       }
     }
     cancel() {
       if (dart.notNull(hasTimer())) {
         if (dart.notNull(this[_inEventLoop])) {
           dart.throw(new core.UnsupportedError("Timer in event loop cannot be canceled."));
         }
-        if (this[_handle] == null)
-          return;
+        if (this[_handle] == null) return;
         leaveJsAsync();
         if (dart.notNull(this[_once])) {
           self.clearTimeout(this[_handle]);
         } else {
           self.clearInterval(this[_handle]);
         }
         this[_handle] = null;
       } else {
         dart.throw(new core.UnsupportedError("Canceling a timer."));
       }
@@ skipping 27 matching lines @@
       hash = dart.notNull(hash) >> 0 ^ (dart.notNull(hash) / 4294967296)[dartx.truncate]();
       hash = ~dart.notNull(hash) + (dart.notNull(hash) << 15) & 4294967295;
       hash = dart.notNull(hash) ^ dart.notNull(hash) >> 12;
       hash = dart.notNull(hash) * 5 & 4294967295;
       hash = dart.notNull(hash) ^ dart.notNull(hash) >> 4;
       hash = dart.notNull(hash) * 2057 & 4294967295;
       hash = dart.notNull(hash) ^ dart.notNull(hash) >> 16;
       return hash;
     }
     ['=='](other) {
-      if (dart.notNull(core.identical(other, this)))
-        return true;
+      if (dart.notNull(core.identical(other, this))) return true;
       if (dart.is(other, CapabilityImpl)) {
         return core.identical(this[_id], other[_id]);
       }
       return false;
     }
   }
   CapabilityImpl[dart.implements] = () => [isolate.Capability];
   dart.defineNamedConstructor(CapabilityImpl, '_internal');
   dart.setSignature(CapabilityImpl, {
     constructors: () => ({
       CapabilityImpl: [CapabilityImpl, []],
       _internal: [CapabilityImpl, [core.int]]
     }),
     methods: () => ({'==': [core.bool, [core.Object]]})
   });
   // Exports:
   exports.enterJsAsync = enterJsAsync;
   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;
 });