stream: remove whitespace changes

Author: rluvaton

lib/internal/streams/readable.js

@@ -183,7 +183,6 @@ function ReadableState(options, stream, isDuplex) {
           this.state |= kObjectMode;
           stream.push = readableAddChunkPushObjectMode;
           stream.unshift = readableAddChunkUnshiftObjectMode;
-
         } else {
           this.state &= ~kObjectMode;
           stream.push = readableAddChunkPushByteMode;
@@ -290,14 +289,16 @@ function Readable(options) {
     }
   });
 
+  const isObjectMode = this._readableState.objectMode;
+
   // Manually shove something into the read() buffer.
   // This returns true if the highWaterMark has not been hit yet,
   // similar to how Writable.write() returns true if you should
   // write() some more.
-  this.push = this._readableState.objectMode ? readableAddChunkPushObjectMode : readableAddChunkPushByteMode;
+  this.push = isObjectMode ? readableAddChunkPushObjectMode : readableAddChunkPushByteMode;
 
   // Unshift should *always* be something directly out of read().
-  this.unshift = this._readableState.objectMode ? readableAddChunkUnshiftObjectMode : readableAddChunkUnshiftByteMode;
+  this.unshift = isObjectMode ? readableAddChunkUnshiftObjectMode : readableAddChunkUnshiftByteMode;
 }
 
 Readable.prototype.destroy = destroyImpl.destroy;
@@ -478,12 +479,12 @@ function canPushMore(state) {
   // Also, if we have no data yet, we can stand some more bytes.
   // This is to work around cases where hwm=0, such as the repl.
   return !state.ended &&
-        (state.length < state.highWaterMark || state.length === 0);
+    (state.length < state.highWaterMark || state.length === 0);
 }
 
 function addChunk(stream, state, chunk, addToFront) {
   if (state.flowing && state.length === 0 && !state.sync &&
-        stream.listenerCount('data') > 0) {
+      stream.listenerCount('data') > 0) {
     // Use the guard to avoid creating `Set()` repeatedly
     // when we have multiple pipes.
     if ((state.state & kMultiAwaitDrain) !== 0) {
@@ -594,11 +595,11 @@ Readable.prototype.read = function(n) {
   // already have a bunch of data in the buffer, then just trigger
   // the 'readable' event and move on.
   if (n === 0 &&
-        state.needReadable &&
-        ((state.highWaterMark !== 0 ?
-          state.length >= state.highWaterMark :
-          state.length > 0) ||
-            state.ended)) {
+      state.needReadable &&
+      ((state.highWaterMark !== 0 ?
+        state.length >= state.highWaterMark :
+        state.length > 0) ||
+       state.ended)) {
     debug('read: emitReadable', state.length, state.ended);
     if (state.length === 0 && state.ended)
       endReadable(this);
@@ -652,7 +653,7 @@ Readable.prototype.read = function(n) {
   // reading, then it's unnecessary, if we're constructing we have to wait,
   // and if we're destroyed or errored, then it's not allowed,
   if (state.ended || state.reading || state.destroyed || state.errored ||
-        !state.constructed) {
+      !state.constructed) {
     doRead = false;
     debug('reading, ended or constructing', doRead);
   } else if (doRead) {
@@ -769,9 +770,9 @@ function emitReadable_(stream) {
   // 3. It is below the highWaterMark, so we can schedule
   //    another readable later.
   state.needReadable =
-        !state.flowing &&
-        !state.ended &&
-        state.length <= state.highWaterMark;
+    !state.flowing &&
+    !state.ended &&
+    state.length <= state.highWaterMark;
   flow(stream);
 }
 
@@ -814,13 +815,13 @@ function maybeReadMore_(stream, state) {
   //   read()s. The execution ends in this method again after the _read() ends
   //   up calling push() with more data.
   while (!state.reading && !state.ended &&
-    (state.length < state.highWaterMark ||
-        (state.flowing && state.length === 0))) {
+         (state.length < state.highWaterMark ||
+          (state.flowing && state.length === 0))) {
     const len = state.length;
     debug('maybeReadMore read 0');
     stream.read(0);
     if (len === state.length)
-    // Didn't get any data, stop spinning.
+      // Didn't get any data, stop spinning.
       break;
   }
   state.readingMore = false;
@@ -851,8 +852,8 @@ Readable.prototype.pipe = function(dest, pipeOpts) {
   debug('pipe count=%d opts=%j', state.pipes.length, pipeOpts);
 
   const doEnd = (!pipeOpts || pipeOpts.end !== false) &&
-        dest !== process.stdout &&
-        dest !== process.stderr;
+              dest !== process.stdout &&
+              dest !== process.stderr;
 
   const endFn = doEnd ? onend : unpipe;
   if (state.endEmitted)
@@ -901,7 +902,7 @@ Readable.prototype.pipe = function(dest, pipeOpts) {
     // So, if this is awaiting a drain, then we just call it now.
     // If we don't know, then assume that we are waiting for one.
     if (ondrain && state.awaitDrainWriters &&
-            (!dest._writableState || dest._writableState.needDrain))
+        (!dest._writableState || dest._writableState.needDrain))
       ondrain();
   }
 
@@ -1010,7 +1011,7 @@ function pipeOnDrain(src, dest) {
     }
 
     if ((!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) &&
-            src.listenerCount('data')) {
+      src.listenerCount('data')) {
       src.resume();
     }
   };
@@ -1305,7 +1306,7 @@ async function* createAsyncIterator(stream, options) {
   } finally {
     if (
       (error || options?.destroyOnReturn !== false) &&
-            (error === undefined || stream._readableState.autoDestroy)
+      (error === undefined || stream._readableState.autoDestroy)
     ) {
       destroyImpl.destroyer(stream, null);
     } else {
@@ -1328,7 +1329,7 @@ ObjectDefineProperties(Readable.prototype, {
       // Compat. The user might manually disable readable side through
       // deprecated setter.
       return !!r && r.readable !== false && !r.destroyed && !r.errorEmitted &&
-                !r.endEmitted;
+        !r.endEmitted;
     },
     set(val) {
       // Backwards compat.
@@ -1352,8 +1353,8 @@ ObjectDefineProperties(Readable.prototype, {
     get: function() {
       return !!(
         this._readableState.readable !== false &&
-                (this._readableState.destroyed || this._readableState.errored) &&
-                !this._readableState.endEmitted
+        (this._readableState.destroyed || this._readableState.errored) &&
+        !this._readableState.endEmitted
       );
     },
   },
@@ -1523,7 +1524,7 @@ function endReadableNT(state, stream) {
 
   // Check that we didn't get one last unshift.
   if (!state.errored && !state.closeEmitted &&
-        !state.endEmitted && state.length === 0) {
+      !state.endEmitted && state.length === 0) {
     state.endEmitted = true;
     stream.emit('end');
 
@@ -1535,9 +1536,9 @@ function endReadableNT(state, stream) {
       const wState = stream._writableState;
       const autoDestroy = !wState || (
         wState.autoDestroy &&
-                // We don't expect the writable to ever 'finish'
-                // if writable is explicitly set to false.
-                (wState.finished || wState.writable === false)
+        // We don't expect the writable to ever 'finish'
+        // if writable is explicitly set to false.
+        (wState.finished || wState.writable === false)
       );
 
       if (autoDestroy) {
@@ -1549,7 +1550,7 @@ function endReadableNT(state, stream) {
 
 function endWritableNT(stream) {
   const writable = stream.writable && !stream.writableEnded &&
-        !stream.destroyed;
+    !stream.destroyed;
   if (writable) {
     stream.end();
   }