docs: function () {
              var series = this,
                seriesOptions = series.options,
                normalOptions = defaultPlotOptions[series.type].marker ? seriesOptions.marker : seriesOptions,
                stateOptions = normalOptions.states,
                stateOptionsHover = stateOptions[HOVER_STATE],
                pointStateOptionsHover,
                seriesColor = series.color,
                normalDefaults = {
                    stroke: seriesColor,
                    fill: seriesColor
                },
                points = series.points || [], // #927
                i,
                point,
                seriesPointAttr = [],
                pointAttr,
                pointAttrToOptions = series.pointAttrToOptions,
                hasPointSpecificOptions = series.hasPointSpecificOptions,
                negativeColor = seriesOptions.negativeColor,
                defaultLineColor = normalOptions.lineColor,
                defaultFillColor = normalOptions.fillColor,
                turboThreshold = seriesOptions.turboThreshold,
                attr,
                key;
  
              // series type specific modifications
              if (seriesOptions.marker) { // line, spline, area, areaspline, scatter
  
                  // if no hover radius is given, default to normal radius + 2
                  stateOptionsHover.radius = stateOptionsHover.radius || normalOptions.radius + stateOptionsHover.radiusPlus;
                  stateOptionsHover.lineWidth = stateOptionsHover.lineWidth || normalOptions.lineWidth + stateOptionsHover.lineWidthPlus;
  
              } 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 = points.length;
              if (!turboThreshold || i < turboThreshold || hasPointSpecificOptions) {
                  while (i--) {
                      point = points[i];
                      normalOptions = (point.options && point.options.marker) || point.options;
                      if (normalOptions && normalOptions.enabled === false) {
                          normalOptions.radius = 0;
                      }
  
                      if (point.negative && negativeColor) {
                          point.color = point.fillColor = negativeColor;
                      }
  
                      hasPointSpecificOptions = seriesOptions.colorByPoint || point.color; // #868
  
                      // 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) {
                          normalOptions = normalOptions || {};
                          pointAttr = [];
                          stateOptions = normalOptions.states || {}; // reassign for individual point
                          pointStateOptionsHover = stateOptions[HOVER_STATE] = stateOptions[HOVER_STATE] || {};
  
                          // Handle colors for column and pies
                          if (!seriesOptions.marker) { // column, bar, point
                              // If no hover color is given, brighten the normal color. #1619, #2579
                              pointStateOptionsHover.color = pointStateOptionsHover.color || (!point.options.color && stateOptionsHover.color) ||
                                Color(point.color)
                                  .brighten(pointStateOptionsHover.brightness || stateOptionsHover.brightness)
                                  .get();
                          }
  
                          // normal point state inherits series wide normal state
                          attr = { color: point.color }; // #868
                          if (!defaultFillColor) { // Individual point color or negative color markers (#2219)
                              attr.fillColor = point.color;
                          }
                          if (!defaultLineColor) {
                              attr.lineColor = point.color; // Bubbles take point color, line markers use white
                          }
                          pointAttr[NORMAL_STATE] = series.convertAttribs(extend(attr, 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;
                  }
              }
          }