docs: function () {
  		var series = this,
  			normalOptions = defaultPlotOptions[series.type].marker ? series.options.marker : series.options,
  			stateOptions = normalOptions.states,
  			stateOptionsHover = stateOptions[HOVER_STATE],
  			pointStateOptionsHover,
  			seriesColor = series.color,
  			normalDefaults = {
  				stroke: seriesColor,
  				fill: seriesColor
  			},
  			data = series.data,
  			i,
  			point,
  			seriesPointAttr = [],
  			pointAttr,
  			pointAttrToOptions = series.pointAttrToOptions,
  			hasPointSpecificOptions,
  			key;
  
  		// series type specific modifications
  		if (series.options.marker) { // line, spline, area, areaspline, scatter
  
  			// if no hover radius is given, default to normal radius + 2
  			stateOptionsHover.radius = stateOptionsHover.radius || normalOptions.radius + 2;
  			stateOptionsHover.lineWidth = stateOptionsHover.lineWidth || normalOptions.lineWidth + 1;
  
  		} else { // column, bar, pie
  
  			// if no hover color is given, brighten the normal color
  			stateOptionsHover.color = stateOptionsHover.color ||
  				Color(stateOptionsHover.color || seriesColor)
  					.brighten(stateOptionsHover.brightness).get();
  		}
  
  		// general point attributes for the series normal state
  		seriesPointAttr[NORMAL_STATE] = series.convertAttribs(normalOptions, normalDefaults);
  
  		// HOVER_STATE and SELECT_STATE states inherit from normal state except the default radius
  		each([HOVER_STATE, SELECT_STATE], function (state) {
  			seriesPointAttr[state] =
  					series.convertAttribs(stateOptions[state], seriesPointAttr[NORMAL_STATE]);
  		});
  
  		// set it
  		series.pointAttr = seriesPointAttr;
  
  
  		// Generate the point-specific attribute collections if specific point
  		// options are given. If not, create a referance to the series wide point
  		// attributes
  		i = data.length;
  		while (i--) {
  			point = data[i];
  			normalOptions = (point.options && point.options.marker) || point.options;
  			if (normalOptions && normalOptions.enabled === false) {
  				normalOptions.radius = 0;
  			}
  			hasPointSpecificOptions = false;
  
  			// check if the point has specific visual options
  			if (point.options) {
  				for (key in pointAttrToOptions) {
  					if (defined(normalOptions[pointAttrToOptions[key]])) {
  						hasPointSpecificOptions = true;
  					}
  				}
  			}
  
  
  
  			// a specific marker config object is defined for the individual point:
  			// create it's own attribute collection
  			if (hasPointSpecificOptions) {
  
  				pointAttr = [];
  				stateOptions = normalOptions.states || {}; // reassign for individual point
  				pointStateOptionsHover = stateOptions[HOVER_STATE] = stateOptions[HOVER_STATE] || {};
  
  				// if no hover color is given, brighten the normal color
  				if (!series.options.marker) { // column, bar, point
  					pointStateOptionsHover.color =
  						Color(pointStateOptionsHover.color || point.options.color)
  							.brighten(pointStateOptionsHover.brightness ||
  								stateOptionsHover.brightness).get();
  
  				}
  
  				// normal point state inherits series wide normal state
  				pointAttr[NORMAL_STATE] = series.convertAttribs(normalOptions, seriesPointAttr[NORMAL_STATE]);
  
  				// inherit from point normal and series hover
  				pointAttr[HOVER_STATE] = series.convertAttribs(
  					stateOptions[HOVER_STATE],
  					seriesPointAttr[HOVER_STATE],
  					pointAttr[NORMAL_STATE]
  				);
  				// inherit from point normal and series hover
  				pointAttr[SELECT_STATE] = series.convertAttribs(
  					stateOptions[SELECT_STATE],
  					seriesPointAttr[SELECT_STATE],
  					pointAttr[NORMAL_STATE]
  				);
  
  
  
  			// no marker config object is created: copy a reference to the series-wide
  			// attribute collection
  			} else {
  				pointAttr = seriesPointAttr;
  			}
  
  			point.pointAttr = pointAttr;
  
  		}
  
  	}