docs: function parseStats(cssObject) {
  
          var css = cssObject.concat;
  
          grunt.log.writeln(app.chalkSuccess('grunt-css-statistics start to build object from cssstats result ...'));
  
          var origin = app.cssstats(css);
          var stats = {
              fileSize:          {
                  size:     getSizeUnit(origin.size),
                  gzipSize: getSizeUnit(origin.gzipSize)
              },
              selectorSpecifity: {},
  
              totals: {
                  rules:          origin.rules.total,
                  selectors:      origin.selectors.total,
                  declarations:   origin.declarations.total,
                  properties:     0,
                  vendorPrefixes: origin.declarations.getVendorPrefixed().length,
                  mediaQueries:   origin.mediaQueries.total,
                  importants:     css.match(/!important/g || []) ? css.match(/!important/g || []).length : 0
              },
  
  
              uniqueDeclarations: {},
  
              selectors: {
                  "type":          origin.selectors.type,
                  "class":         origin.selectors.class,
                  "id":            origin.selectors.id,
                  "pseudoClass":   origin.selectors.pseudoClass,
                  "pseudoElement": origin.selectors.pseudoElement
              },
  
              propertyResets: {},
  
              uniqueValues: {
                  colors:           getValueCount(origin.declarations.properties['color'], 'color'),
                  backgroundColors: {},
                  fontSizes:        {},
                  fontFamilies:     getValueCount(origin.declarations.properties['font-family'], 'font-family')
              },
  
              uniqueMediaQueries: getValueCount(origin.mediaQueries.values, 'mediaQueries')
          };
  
          if (options.addGraphs) {
              grunt.log.writeln('adding graph data ...');
  
              stats.graphs = {};
              stats.graphs.selectorSpecificity = origin.selectors.getSpecificityGraph();
              stats.graphs.rulesetSize = origin.rules.size.graph;
          }
  
          if (options.addRawCss) {
              grunt.log.writeln('adding concatinated raw css ...');
              stats.rawCss = css;
          }
  
          if (options.addOrigin) {
              grunt.log.writeln(app.chalkInfo('adding original cssstats object ...'));
              stats.origin = origin;
          }
  
          // get all unique declarations
          for (var prop in origin.declarations.properties) {
              if (origin.declarations.properties.hasOwnProperty(prop)) {
                  if (options.uniqueDeclarations.indexOf(prop) > -1) {
  
                      grunt.log.writeln('determine unique declarations of "' + app.chalkInfo(prop) + '" ...');
  
                      stats.uniqueDeclarations[prop] = origin.declarations.properties[prop].length;
                  }
                  stats.totals.properties = stats.totals.properties + 1;
              }
          }
          // get colors from shorthand attribute 'background'
          var bgColors = origin.declarations.properties['background-color'] ?
              origin.declarations.properties['background-color'] :
              [];
  
          if (origin.declarations.properties['background']) {
              grunt.log.writeln('determine background-colors from background properties ...');
  
              origin.declarations.properties['background'].forEach(function (bg) {
  
                  var bgColor = bg.match(/#[0-9a-fA-F]+|#[0-9]|#[A-F]+|#[a-f]+|(rgba|rgb)\([0-9,.]+?\)/g);
  
                  if (bgColor) {
                      bgColors.push(bgColor[0]);
                  }
              });
          }
  
          stats.uniqueValues.backgroundColors = getValueCount(bgColors, 'bgColors');
  
          // get font sizes from shorthand attribute 'font'
          var fontSizes = origin.declarations.properties['font-size'] ?
              origin.declarations.properties['font-size'] :
              [];
  
          if (origin.declarations.properties['font']) {
              grunt.log.writeln('determine font-sizes from font properties ...');
  
              origin.declarations.properties['font'].forEach(function (f) {
                  var fontSize = f.match(/([\d.])+ ?(em|ex|%|dpx|px|cm|mm|in|pt|pc|ch|rem|vh|vw|vmin|vmax)\/?[\d.]?|(inherit|small|smaller|big|bigger)/g);
  
                  if (fontSize) {
                      fontSizes.push(fontSize[0]);
                  }
              });
          }
  
          stats.uniqueValues.fontSizes = sortFontSizes(getValueCount(fontSizes), 'fontSizes');
  
  
          stats.propertyResets = origin.declarations.getPropertyResets();
          stats.selectorSpecifity = origin.selectors.specificity;
  
          if (options.csslint) {
  
              var linted = app.parseCsslint(app, options.csslint, cssObject);
  
              if (linted) {
                  stats.lint = linted;
              }
          }
  
          return stats;
      }