docs: function zip_deflate_fast() {
      while (zip_lookahead != 0 && zip_qhead == null) {
          var flush; // set if current block must be flushed
  
          /* Insert the string window[strstart .. strstart+2] in the
           * dictionary, and set hash_head to the head of the hash chain:
           */
          zip_INSERT_STRING();
  
          /* Find the longest match, discarding those <= prev_length.
           * At this point we have always match_length < MIN_MATCH
           */
          if (zip_hash_head != zip_NIL &&
              zip_strstart - zip_hash_head <= zip_MAX_DIST) {
              /* To simplify the code, we prevent matches with the string
               * of window index 0 (in particular we have to avoid a match
               * of the string with itself at the start of the input file).
               */
              zip_match_length = zip_longest_match(zip_hash_head);
              /* longest_match() sets match_start */
              if (zip_match_length > zip_lookahead)
                  zip_match_length = zip_lookahead;
          }
          if (zip_match_length >= zip_MIN_MATCH) {
              //      check_match(strstart, match_start, match_length);
  
              flush = zip_ct_tally(zip_strstart - zip_match_start,
                  zip_match_length - zip_MIN_MATCH);
              zip_lookahead -= zip_match_length;
  
              /* Insert new strings in the hash table only if the match length
               * is not too large. This saves time but degrades compression.
               */
              if (zip_match_length <= zip_max_lazy_match) {
                  zip_match_length--; // string at strstart already in hash table
                  do {
                      zip_strstart++;
                      zip_INSERT_STRING();
                      /* strstart never exceeds WSIZE-MAX_MATCH, so there are
                       * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
                       * these bytes are garbage, but it does not matter since
                       * the next lookahead bytes will be emitted as literals.
                       */
                  } while (--zip_match_length != 0);
                  zip_strstart++;
              } else {
                  zip_strstart += zip_match_length;
                  zip_match_length = 0;
                  zip_ins_h = zip_window[zip_strstart] & 0xff;
                  //      UPDATE_HASH(ins_h, window[strstart + 1]);
                  zip_ins_h = ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[zip_strstart + 1] & 0xff)) & zip_HASH_MASK;
  
                  //#if MIN_MATCH != 3
                  //      Call UPDATE_HASH() MIN_MATCH-3 more times
                  //#endif
  
              }
          } else {
              /* No match, output a literal byte */
              flush = zip_ct_tally(0, zip_window[zip_strstart] & 0xff);
              zip_lookahead--;
              zip_strstart++;
          }
          if (flush) {
              zip_flush_block(0);
              zip_block_start = zip_strstart;
          }
  
          /* Make sure that we always have enough lookahead, except
           * at the end of the input file. We need MAX_MATCH bytes
           * for the next match, plus MIN_MATCH bytes to insert the
           * string following the next match.
           */
          while (zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
              zip_fill_window();
      }
  }