text: /**
   * Optional automatic rollup logic for reducing http connections
   * when not using a combo service.
   * @module loader
   * @submodule rollup
   */
  
  /**
   * Look for rollup packages to determine if all of the modules a
   * rollup supersedes are required.  If so, include the rollup to
   * help reduce the total number of connections required.  Called
   * by calculate().  This is an optional feature, and requires the
   * appropriate submodule to function.
   * @method _rollup
   * @for Loader
   * @private
   */
  Y.Loader.prototype._rollup = function() {
      var i, j, m, s, r = this.required, roll,
          info = this.moduleInfo, rolled, c, smod;
  
      // find and cache rollup modules
      if (this.dirty || !this.rollups) {
          this.rollups = {};
          for (i in info) {
              if (info.hasOwnProperty(i)) {
                  m = this.getModule(i);
                  // if (m && m.rollup && m.supersedes) {
                  if (m && m.rollup) {
                      this.rollups[i] = m;
                  }
              }
          }
      }
  
      // make as many passes as needed to pick up rollup rollups
      for (;;) {
          rolled = false;
  
          // go through the rollup candidates
          for (i in this.rollups) {
              if (this.rollups.hasOwnProperty(i)) {
                  // there can be only one, unless forced
                  if (!r[i] && ((!this.loaded[i]) || this.forceMap[i])) {
                      m = this.getModule(i);
                      s = m.supersedes || [];
                      roll = false;
  
                      // @TODO remove continue
                      if (!m.rollup) {
                          continue;
                      }
  
                      c = 0;
  
                      // check the threshold
                      for (j = 0; j < s.length; j++) {
                          smod = info[s[j]];
  
                          // if the superseded module is loaded, we can't
                          // load the rollup unless it has been forced.
                          if (this.loaded[s[j]] && !this.forceMap[s[j]]) {
                              roll = false;
                              break;
                          // increment the counter if this module is required.
                          // if we are beyond the rollup threshold, we will
                          // use the rollup module
                          } else if (r[s[j]] && m.type === smod.type) {
                              c++;
                              // Y.log("adding to thresh: " + c + ", " + s[j]);
                              roll = (c >= m.rollup);
                              if (roll) {
                                  // Y.log("over thresh " + c + ", " + s[j]);
                                  break;
                              }
                          }
                      }
  
                      if (roll) {
                          // Y.log("adding rollup: " +  i);
                          // add the rollup
                          r[i] = true;
                          rolled = true;
  
                          // expand the rollup's dependencies
                          this.getRequires(m);
                      }
                  }
              }
          }
  
          // if we made it here w/o rolling up something, we are done
          if (!rolled) {
              break;
          }
      }
  };
  