diff --git a/lib/zlib/deflate.js b/lib/zlib/deflate.js
index de91a8c..efd7ea8 100644
--- a/lib/zlib/deflate.js
+++ b/lib/zlib/deflate.js
@@ -496,17 +496,20 @@ const deflate_stored = (s, flush) => {
    * possible. If flushing, copy the remaining available input to next_out as
    * stored blocks, if there is enough space.
    */
-  let len, left, have, last;
+  let len, left, have, last = 0;
   let used = s.strm.avail_in;
-  for (;;) {
+  do {
     /* Set len to the maximum size block that we can copy directly with the
      * available input data and output space. Set left to how much of that
      * would be copied from what's left in the window.
      */
     len = 65535/* MAX_STORED */;     /* maximum deflate stored block length */
     have = (s.bi_valid + 42) >> 3;     /* number of header bytes */
+    if (s.strm.avail_out < have) {         /* need room for header */
+      break;
+    }
       /* maximum stored block length that will fit in avail_out: */
-    have = s.strm.avail_out > have ? s.strm.avail_out - have : 0;
+    have = s.strm.avail_out - have;
     left = s.strstart - s.block_start;  /* bytes left in window */
     if (len > left + s.strm.avail_in) {
       len = left + s.strm.avail_in;   /* limit len to the input */
@@ -523,8 +526,9 @@ const deflate_stored = (s, flush) => {
      * copying to the window and the pending buffer instead. Also don't
      * write an empty block when flushing -- deflate() does that.
      */
-    if (len < min_block && (len === 0 || flush === Z_NO_FLUSH ||
-                len - left !== s.strm.avail_in)) {
+    if (len < min_block && ((len === 0 && flush !== Z_FINISH) ||
+                        flush === Z_NO_FLUSH ||
+                        len - left !== s.strm.avail_in)) {
       break;
     }
 
@@ -569,7 +573,7 @@ const deflate_stored = (s, flush) => {
       s.strm.avail_out -= len;
       s.strm.total_out += len;
     }
-  }
+  } while (last === 0);
 
   /* Update the sliding window with the last s->w_size bytes of the copied
    * data, or append all of the copied data to the existing window if less
@@ -606,13 +610,15 @@ const deflate_stored = (s, flush) => {
     s.insert += used > s.w_size - s.insert ? s.w_size - s.insert : used;
   }
 
-  /* If flushing or finishing and all input has been consumed, then done. If
-   * the code above couldn't write a complete block to next_out, then the
-   * code following this won't be able to either.
-   */
-  if (flush !== Z_NO_FLUSH && s.strm.avail_in === 0 &&
-    s.strstart === s.block_start) {
-    return flush === Z_FINISH ? BS_FINISH_DONE : BS_BLOCK_DONE;
+  /* If the last block was written to next_out, then done. */
+  if (last) {
+    return BS_FINISH_DONE;
+  }
+
+  /* If flushing and all input has been consumed, then done. */
+  if (flush !== Z_NO_FLUSH && flush !== Z_FINISH &&
+    s.strm.avail_in === 0 && s.strstart === s.block_start) {
+    return BS_BLOCK_DONE;
   }
 
   /* Fill the window with any remaining input. */
@@ -647,21 +653,18 @@ const deflate_stored = (s, flush) => {
   min_block = have > s.w_size ? s.w_size : have;
   left = s.strstart - s.block_start;
   if (left >= min_block ||
-    (left && flush !== Z_NO_FLUSH && s.strm.avail_in === 0 &&
-     left <= have)) {
+     ((left || flush === Z_FINISH) && flush !== Z_NO_FLUSH &&
+     s.strm.avail_in === 0 && left <= have)) {
     len = left > have ? have : left;
     last = flush === Z_FINISH && s.strm.avail_in === 0 &&
          len === left ? 1 : 0;
     _tr_stored_block(s, s.block_start, len, last);
     s.block_start += len;
     flush_pending(s.strm);
-    if (last) {
-      return BS_FINISH_STARTED;
-    }
   }
 
   /* We've done all we can with the available input and output. */
-  return BS_NEED_MORE;
+  return last ? BS_FINISH_STARTED : BS_NEED_MORE;
 };
 
 
@@ -1840,8 +1843,6 @@ const deflate = (strm, flush) => {
       }
     }
   }
-  //Assert(strm->avail_out > 0, "bug2");
-  //if (strm.avail_out <= 0) { throw new Error("bug2");}
 
   if (flush !== Z_FINISH) { return Z_OK; }
   if (s.wrap <= 0) { return Z_STREAM_END; }