docs: function(itemSet){
  
              this.closureCount = this.closureCount || 0;
              this.closureCount++;
  
              var self = this,
              closureItemSet = new DataTypes.ItemSet();
  
              var set = itemSet,
                  itemQueue;
              do{         //C0
                  itemQueue = new DataTypes.ItemSet();
                  closureItemSet.union(set);
  
                  _.each(set.subItems, function(item){        //each closureItems
                      if(item.dotSymbol && self.nonterminals[item.dotSymbol]){
                          /*
                          if(!closureSymbolHash[item.dotSymbol]){         //exists un derivation nonterminal
                          */
                              var afterRhs = item.production.rhs.slice(item.dotPosition+1);
                              lookaheads = self._first(afterRhs);
                              if(lookaheads.length === 0 || item.production.nullable || self._nullable(afterRhs)){
                                  lookaheads = _.union(lookaheads, item.lookaheads);
                              }
  
                              _.each(self.nonterminals[item.dotSymbol].productions, function(p){
                                      var item = new DataTypes.Item(p, 0, lookaheads);
                                      if(!closureItemSet.contains(item) && !itemQueue.contains(item)){
                                          itemQueue.push(item); //new clsoure-item
                                      }
                              });
  
  
                              /**
                               * 求闭包的项的输入点非终结符后面的RHS 和 求闭包的项的每个lookahead符号 连接
                               * 然后进行FIRSTS运算，拿到lookaheads
                               * 每个lookaheads，进行并集运算，得到最终的lookaheads
                               */
                              /*
                              var lookaheads = [];
                              _.each(item.lookaheads, function(fchr){
                                  var afterRHS = item.production.rhs.slice(item.dotPosition+1)
                                      afterRHS.push(fchr);
                                      lookaheads = _.union(lookaheads, self._first(afterRHS));
                              });
                              */
  
                              //求闭包的项的输入点非终结符，的每个产生式p
                              //查找闭包集合中是否已经存在相同核心的产生式
                              //存在则合并lookaheads
                              //不存在则创建
                              /*
                              _.each(self.nonterminals[item.dotSymbol].productions, function(p){
                                      var item = new DataTypes.Item(p, 0, lookaheads),
                                      itemIdx;
                                      if((itemIdx = closureItemSet.coreIndexOf(item)) === -1){
                                          itemSet.push(item); //new clsoure-item
                                          cont = true;                            //C0不动点循环继续
                                      }else{
                                          item = closureItemSet.subItems[itemIdx];
                                          item.lookaheads = _.union(item.lookaheads, lookaheads);
                                      }
                              });
                              */
                              //closureSymbolHash[item.dotSymbol] = true;   //cur nonterminal derivated
                              /*
                          }
                          */
                      }
                  });
                  set = itemQueue;
              }while(set.subItems.length);
  
              return closureItemSet;
          }