docs: function () {
              var plotLine = this,
                axis = plotLine.axis,
                horiz = axis.horiz,
                halfPointRange = (axis.pointRange || 0) / 2,
                options = plotLine.options,
                optionsLabel = options.label,
                label = plotLine.label,
                width = options.width,
                to = options.to,
                from = options.from,
                isBand = defined(from) && defined(to),
                value = options.value,
                dashStyle = options.dashStyle,
                svgElem = plotLine.svgElem,
                path = [],
                addEvent,
                eventType,
                xs,
                ys,
                x,
                y,
                color = options.color,
                zIndex = options.zIndex,
                events = options.events,
                attribs = {},
                renderer = axis.chart.renderer;
  
              // logarithmic conversion
              if (axis.isLog) {
                  from = log2lin(from);
                  to = log2lin(to);
                  value = log2lin(value);
              }
  
              // plot line
              if (width) {
                  path = axis.getPlotLinePath(value, width);
                  attribs = {
                      stroke: color,
                      'stroke-width': width
                  };
                  if (dashStyle) {
                      attribs.dashstyle = dashStyle;
                  }
              } else if (isBand) { // plot band
  
                  // keep within plot area
                  from = mathMax(from, axis.min - halfPointRange);
                  to = mathMin(to, axis.max + halfPointRange);
  
                  path = axis.getPlotBandPath(from, to, options);
                  if (color) {
                      attribs.fill = color;
                  }
                  if (options.borderWidth) {
                      attribs.stroke = options.borderColor;
                      attribs['stroke-width'] = options.borderWidth;
                  }
              } else {
                  return;
              }
              // zIndex
              if (defined(zIndex)) {
                  attribs.zIndex = zIndex;
              }
  
              // common for lines and bands
              if (svgElem) {
                  if (path) {
                      svgElem.animate({
                          d: path
                      }, null, svgElem.onGetPath);
                  } else {
                      svgElem.hide();
                      svgElem.onGetPath = function () {
                          svgElem.show();
                      };
                      if (label) {
                          plotLine.label = label = label.destroy();
                      }
                  }
              } else if (path && path.length) {
                  plotLine.svgElem = svgElem = renderer.path(path)
                    .attr(attribs).add();
  
                  // events
                  if (events) {
                      addEvent = function (eventType) {
                          svgElem.on(eventType, function (e) {
                              events[eventType].apply(plotLine, [e]);
                          });
                      };
                      for (eventType in events) {
                          addEvent(eventType);
                      }
                  }
              }
  
              // the plot band/line label
              if (optionsLabel && defined(optionsLabel.text) && path && path.length && axis.width > 0 && axis.height > 0) {
                  // apply defaults
                  optionsLabel = merge({
                      align: horiz && isBand && 'center',
                      x: horiz ? !isBand && 4 : 10,
                      verticalAlign : !horiz && isBand && 'middle',
                      y: horiz ? isBand ? 16 : 10 : isBand ? 6 : -4,
                      rotation: horiz && !isBand && 90
                  }, optionsLabel);
  
                  // add the SVG element
                  if (!label) {
                      attribs = {
                          align: optionsLabel.textAlign || optionsLabel.align,
                          rotation: optionsLabel.rotation
                      };
                      if (defined(zIndex)) {
                          attribs.zIndex = zIndex;
                      }
                      plotLine.label = label = renderer.text(
                        optionsLabel.text,
                        0,
                        0,
                        optionsLabel.useHTML
                        )
                        .attr(attribs)
                        .css(optionsLabel.style)
                        .add();
                  }
  
                  // get the bounding box and align the label
                  // #3000 changed to better handle choice between plotband or plotline
                  xs = [path[1], path[4], (isBand ? path[6] : path[1])];
                  ys = [path[2], path[5], (isBand ? path[7] : path[2])];
                  x = arrayMin(xs);
                  y = arrayMin(ys);
  
                  label.align(optionsLabel, false, {
                      x: x,
                      y: y,
                      width: arrayMax(xs) - x,
                      height: arrayMax(ys) - y
                  });
                  label.show();
  
              } else if (label) { // move out of sight
                  label.hide();
              }
  
              // chainable
              return plotLine;
          }