docs: function(eof) { // true if this is the last block for a file
      var opt_lenb, static_lenb; // opt_len and static_len in bytes
      var max_blindex;	// index of last bit length code of non zero freq
      var stored_len;	// length of input block
  
      stored_len = zip_strstart - zip_block_start;
      zip_flag_buf[zip_last_flags] = zip_flags; // Save the flags for the last 8 items
  
      // Construct the literal and distance trees
      zip_build_tree(zip_l_desc);
  //    Tracev((stderr, "\nlit data: dyn %ld, stat %ld",
  //	    encoder->opt_len, encoder->static_len));
  
      zip_build_tree(zip_d_desc);
  //    Tracev((stderr, "\ndist data: dyn %ld, stat %ld",
  //	    encoder->opt_len, encoder->static_len));
      /* At this point, opt_len and static_len are the total bit lengths of
       * the compressed block data, excluding the tree representations.
       */
  
      /* Build the bit length tree for the above two trees, and get the index
       * in bl_order of the last bit length code to send.
       */
      max_blindex = zip_build_bl_tree();
  
      // Determine the best encoding. Compute first the block length in bytes
      opt_lenb	= (zip_opt_len   +3+7)>>3;
      static_lenb = (zip_static_len+3+7)>>3;
  
  //    Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
  //	   opt_lenb, encoder->opt_len,
  //	   static_lenb, encoder->static_len, stored_len,
  //	   encoder->last_lit, encoder->last_dist));
  
      if(static_lenb <= opt_lenb)
  	opt_lenb = static_lenb;
      if(stored_len + 4 <= opt_lenb // 4: two words for the lengths
         && zip_block_start >= 0) {
  	var i;
  
  	/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
  	 * Otherwise we can't have processed more than WSIZE input bytes since
  	 * the last block flush, because compression would have been
  	 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
  	 * transform a block into a stored block.
  	 */
  	zip_send_bits((zip_STORED_BLOCK<<1)+eof, 3);  /* send block type */
  	zip_bi_windup();		 /* align on byte boundary */
  	zip_put_short(stored_len);
  	zip_put_short(~stored_len);
  
        // copy block
  /*
        p = &window[block_start];
        for(i = 0; i < stored_len; i++)
  	put_byte(p[i]);
  */
  	for(i = 0; i < stored_len; i++)
  	    zip_put_byte(zip_window[zip_block_start + i]);
  
      } else if(static_lenb == opt_lenb) {
  	zip_send_bits((zip_STATIC_TREES<<1)+eof, 3);
  	zip_compress_block(zip_static_ltree, zip_static_dtree);
      } else {
  	zip_send_bits((zip_DYN_TREES<<1)+eof, 3);
  	zip_send_all_trees(zip_l_desc.max_code+1,
  			   zip_d_desc.max_code+1,
  			   max_blindex+1);
  	zip_compress_block(zip_dyn_ltree, zip_dyn_dtree);
      }
  
      zip_init_block();
  
      if(eof != 0)
  	zip_bi_windup();
  }