docs: function rudePackager(ret, pack, settings, opt) {
    var files = ret.src;
    var sources = _.toArray(files);
  
    // 生成映射表，方便快速查找！
    var idmapping = ret.idmapping = {};
    var urlmapping = ret.urlmapping = {};
    Object.keys(files).forEach(function(subpath) {
      var file = files[subpath];
      idmapping[file.id] = file;
      if (file.release) {
        urlmapping[file.getUrl()] = file;
      }
    });
  
    var includeList = [];
    // 如果有设置需要额外的模块加入到 resouceMap 当中
    if (settings.include) {
      var patterns = settings.include;
      if (!Array.isArray(patterns)) {
        patterns = [patterns];
      }
  
      
      patterns.forEach(function(pattern, index) {
        var exclude = typeof pattern === 'string' && pattern.substring(0, 1) === '!';
  
        if (exclude) {
          pattern = pattern.substring(1);
  
          // 如果第一个规则就是排除用法，都没有获取结果就排除，这是不合理的用法。
          // 不过为了保证程序的正确性，在排除之前，通过 `**` 先把所有文件获取到。
          // 至于性能问题，请用户使用时规避。
          index === 0 && (includeList = find('**'));
        }
  
        var mathes = find(pattern);
        includeList = _[exclude ? 'difference' : 'union'](includeList, mathes);
      });
    }
  
    Object.keys(files).forEach(function(subpath) {
      var file = files[subpath];
  
      compile(file);
    });
  
    function find(reg) {
      if (files[reg]) {
        return [files[reg]];
      } else if (reg === '**') {
        // do nothing
      } else if (typeof reg === 'string') {
        reg = _.glob(reg);
      }
  
      return sources.filter(function(file) {
        reg.lastIndex = 0;
        return (reg === '**' || reg.test(file.subpath));
      });
    }
  
    function compile(file) {
      var processor = rudePackager.lang[file.loaderLang] ||
        rudePackager.lang[settings.processor[file.ext]] ||
        rudePackager.lang.html;
  
      // 非 htmlLike 或者 没有处理器，或者已经处理过了，则跳过。
      if (file.release === false ||
          !file.isHtmlLike ||
          file.loaderLang === false ||
          file.loaderLang === null ||
          !processor ||
          file._resource) {
        return;
      }
  
      // 可以让 processor 调用。
      processor._compile = compile;
  
      // 修改之前先，先备份。
      file._rudeBackup = file.getContent();
  
      var resource = createResource(ret, file, settings);
      file._resource = resource;
      processor.init && processor.init(file, resource, settings);
  
      processor.beforePack && processor.beforePack(file, resource, settings, includeList);
  
      if (settings.allInOne) {
        allInOnePack(file, resource, ret, settings.allInOne === true ? {} : settings.allInOne);
      }
  
      processor.before && processor.before(file, resource, settings);
      processor(file, resource, settings);
      processor.after && processor.after(file, resource, settings);
  
      file.useCache = false; // 让其缓存失效，watch 的时候，下次需要重新发布过去。
      ret.pkg[file.subpath] = file;
    }
  }