docs: function () {
  			var plotLine = this,
  				options = plotLine.options,
  				optionsLabel = options.label,
  				label = plotLine.label,
  				width = options.width,
  				to = options.to,
  				from = options.from,
  				value = options.value,
  				toPath, // bands only
  				dashStyle = options.dashStyle,
  				svgElem = plotLine.svgElem,
  				path = [],
  				addEvent,
  				eventType,
  				xs,
  				ys,
  				x,
  				y,
  				color = options.color,
  				zIndex = options.zIndex,
  				events = options.events,
  				attribs;
  
  			// logarithmic conversion
  			if (isLog) {
  				from = log2lin(from);
  				to = log2lin(to);
  				value = log2lin(value);
  			}
  
  			// plot line
  			if (width) {
  				path = getPlotLinePath(value, width);
  				attribs = {
  					stroke: color,
  					'stroke-width': width
  				};
  				if (dashStyle) {
  					attribs.dashstyle = dashStyle;
  				}
  			} else if (defined(from) && defined(to)) { // plot band
  				// keep within plot area
  				from = mathMax(from, min);
  				to = mathMin(to, max);
  
  				toPath = getPlotLinePath(to);
  				path = getPlotLinePath(from);
  				if (path && toPath) {
  					path.push(
  						toPath[4],
  						toPath[5],
  						toPath[1],
  						toPath[2]
  					);
  				} else { // outside the axis area
  					path = null;
  				}
  				attribs = {
  					fill: color
  				};
  			} 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();
  					};
  				}
  			} 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 && plotWidth > 0 && plotHeight > 0) {
  				// apply defaults
  				optionsLabel = merge({
  					align: horiz && toPath && 'center',
  					x: horiz ? !toPath && 4 : 10,
  					verticalAlign : !horiz && toPath && 'middle',
  					y: horiz ? toPath ? 16 : 10 : toPath ? 6 : -4,
  					rotation: horiz && !toPath && 90
  				}, optionsLabel);
  
  				// add the SVG element
  				if (!label) {
  					plotLine.label = label = renderer.text(
  							optionsLabel.text,
  							0,
  							0
  						)
  						.attr({
  							align: optionsLabel.textAlign || optionsLabel.align,
  							rotation: optionsLabel.rotation,
  							zIndex: zIndex
  						})
  						.css(optionsLabel.style)
  						.add();
  				}
  
  				// get the bounding box and align the label
  				xs = [path[1], path[4], pick(path[6], path[1])];
  				ys = [path[2], path[5], pick(path[7], path[2])];
  				x = mathMin.apply(math, xs);
  				y = mathMin.apply(math, ys);
  
  				label.align(optionsLabel, false, {
  					x: x,
  					y: y,
  					width: mathMax.apply(math, xs) - x,
  					height: mathMax.apply(math, ys) - y
  				});
  				label.show();
  
  			} else if (label) { // move out of sight
  				label.hide();
  			}
  
  			// chainable
  			return plotLine;
  		}