docs: function(chartArea) {
  		var me = this;
  		var options = me.options;
  
  		if (!me._isVisible()) {
  			return;
  		}
  
  		var chart = me.chart;
  		var context = me.ctx;
  		var globalDefaults = core_defaults.global;
  		var defaultFontColor = globalDefaults.defaultFontColor;
  		var optionTicks = options.ticks.minor;
  		var optionMajorTicks = options.ticks.major || optionTicks;
  		var gridLines = options.gridLines;
  		var scaleLabel = options.scaleLabel;
  		var position = options.position;
  
  		var isRotated = me.labelRotation !== 0;
  		var isMirrored = optionTicks.mirror;
  		var isHorizontal = me.isHorizontal();
  
  		var parseFont = helpers$1.options._parseFont;
  		var ticks = optionTicks.display && optionTicks.autoSkip ? me._autoSkip(me.getTicks()) : me.getTicks();
  		var tickFontColor = valueOrDefault$9(optionTicks.fontColor, defaultFontColor);
  		var tickFont = parseFont(optionTicks);
  		var lineHeight = tickFont.lineHeight;
  		var majorTickFontColor = valueOrDefault$9(optionMajorTicks.fontColor, defaultFontColor);
  		var majorTickFont = parseFont(optionMajorTicks);
  		var tickPadding = optionTicks.padding;
  		var labelOffset = optionTicks.labelOffset;
  
  		var tl = gridLines.drawTicks ? gridLines.tickMarkLength : 0;
  
  		var scaleLabelFontColor = valueOrDefault$9(scaleLabel.fontColor, defaultFontColor);
  		var scaleLabelFont = parseFont(scaleLabel);
  		var scaleLabelPadding = helpers$1.options.toPadding(scaleLabel.padding);
  		var labelRotationRadians = helpers$1.toRadians(me.labelRotation);
  
  		var itemsToDraw = [];
  
  		var axisWidth = gridLines.drawBorder ? valueAtIndexOrDefault(gridLines.lineWidth, 0, 0) : 0;
  		var alignPixel = helpers$1._alignPixel;
  		var borderValue, tickStart, tickEnd;
  
  		if (position === 'top') {
  			borderValue = alignPixel(chart, me.bottom, axisWidth);
  			tickStart = me.bottom - tl;
  			tickEnd = borderValue - axisWidth / 2;
  		} else if (position === 'bottom') {
  			borderValue = alignPixel(chart, me.top, axisWidth);
  			tickStart = borderValue + axisWidth / 2;
  			tickEnd = me.top + tl;
  		} else if (position === 'left') {
  			borderValue = alignPixel(chart, me.right, axisWidth);
  			tickStart = me.right - tl;
  			tickEnd = borderValue - axisWidth / 2;
  		} else {
  			borderValue = alignPixel(chart, me.left, axisWidth);
  			tickStart = borderValue + axisWidth / 2;
  			tickEnd = me.left + tl;
  		}
  
  		var epsilon = 0.0000001; // 0.0000001 is margin in pixels for Accumulated error.
  
  		helpers$1.each(ticks, function(tick, index) {
  			// autoskipper skipped this tick (#4635)
  			if (helpers$1.isNullOrUndef(tick.label)) {
  				return;
  			}
  
  			var label = tick.label;
  			var lineWidth, lineColor, borderDash, borderDashOffset;
  			if (index === me.zeroLineIndex && options.offset === gridLines.offsetGridLines) {
  				// Draw the first index specially
  				lineWidth = gridLines.zeroLineWidth;
  				lineColor = gridLines.zeroLineColor;
  				borderDash = gridLines.zeroLineBorderDash || [];
  				borderDashOffset = gridLines.zeroLineBorderDashOffset || 0.0;
  			} else {
  				lineWidth = valueAtIndexOrDefault(gridLines.lineWidth, index);
  				lineColor = valueAtIndexOrDefault(gridLines.color, index);
  				borderDash = gridLines.borderDash || [];
  				borderDashOffset = gridLines.borderDashOffset || 0.0;
  			}
  
  			// Common properties
  			var tx1, ty1, tx2, ty2, x1, y1, x2, y2, labelX, labelY, textOffset, textAlign;
  			var labelCount = helpers$1.isArray(label) ? label.length : 1;
  			var lineValue = getPixelForGridLine(me, index, gridLines.offsetGridLines);
  
  			if (isHorizontal) {
  				var labelYOffset = tl + tickPadding;
  
  				if (lineValue < me.left - epsilon) {
  					lineColor = 'rgba(0,0,0,0)';
  				}
  
  				tx1 = tx2 = x1 = x2 = alignPixel(chart, lineValue, lineWidth);
  				ty1 = tickStart;
  				ty2 = tickEnd;
  				labelX = me.getPixelForTick(index) + labelOffset; // x values for optionTicks (need to consider offsetLabel option)
  
  				if (position === 'top') {
  					y1 = alignPixel(chart, chartArea.top, axisWidth) + axisWidth / 2;
  					y2 = chartArea.bottom;
  					textOffset = ((!isRotated ? 0.5 : 1) - labelCount) * lineHeight;
  					textAlign = !isRotated ? 'center' : 'left';
  					labelY = me.bottom - labelYOffset;
  				} else {
  					y1 = chartArea.top;
  					y2 = alignPixel(chart, chartArea.bottom, axisWidth) - axisWidth / 2;
  					textOffset = (!isRotated ? 0.5 : 0) * lineHeight;
  					textAlign = !isRotated ? 'center' : 'right';
  					labelY = me.top + labelYOffset;
  				}
  			} else {
  				var labelXOffset = (isMirrored ? 0 : tl) + tickPadding;
  
  				if (lineValue < me.top - epsilon) {
  					lineColor = 'rgba(0,0,0,0)';
  				}
  
  				tx1 = tickStart;
  				tx2 = tickEnd;
  				ty1 = ty2 = y1 = y2 = alignPixel(chart, lineValue, lineWidth);
  				labelY = me.getPixelForTick(index) + labelOffset;
  				textOffset = (1 - labelCount) * lineHeight / 2;
  
  				if (position === 'left') {
  					x1 = alignPixel(chart, chartArea.left, axisWidth) + axisWidth / 2;
  					x2 = chartArea.right;
  					textAlign = isMirrored ? 'left' : 'right';
  					labelX = me.right - labelXOffset;
  				} else {
  					x1 = chartArea.left;
  					x2 = alignPixel(chart, chartArea.right, axisWidth) - axisWidth / 2;
  					textAlign = isMirrored ? 'right' : 'left';
  					labelX = me.left + labelXOffset;
  				}
  			}
  
  			itemsToDraw.push({
  				tx1: tx1,
  				ty1: ty1,
  				tx2: tx2,
  				ty2: ty2,
  				x1: x1,
  				y1: y1,
  				x2: x2,
  				y2: y2,
  				labelX: labelX,
  				labelY: labelY,
  				glWidth: lineWidth,
  				glColor: lineColor,
  				glBorderDash: borderDash,
  				glBorderDashOffset: borderDashOffset,
  				rotation: -1 * labelRotationRadians,
  				label: label,
  				major: tick.major,
  				textOffset: textOffset,
  				textAlign: textAlign
  			});
  		});
  
  		// Draw all of the tick labels, tick marks, and grid lines at the correct places
  		helpers$1.each(itemsToDraw, function(itemToDraw) {
  			var glWidth = itemToDraw.glWidth;
  			var glColor = itemToDraw.glColor;
  
  			if (gridLines.display && glWidth && glColor) {
  				context.save();
  				context.lineWidth = glWidth;
  				context.strokeStyle = glColor;
  				if (context.setLineDash) {
  					context.setLineDash(itemToDraw.glBorderDash);
  					context.lineDashOffset = itemToDraw.glBorderDashOffset;
  				}
  
  				context.beginPath();
  
  				if (gridLines.drawTicks) {
  					context.moveTo(itemToDraw.tx1, itemToDraw.ty1);
  					context.lineTo(itemToDraw.tx2, itemToDraw.ty2);
  				}
  
  				if (gridLines.drawOnChartArea) {
  					context.moveTo(itemToDraw.x1, itemToDraw.y1);
  					context.lineTo(itemToDraw.x2, itemToDraw.y2);
  				}
  
  				context.stroke();
  				context.restore();
  			}
  
  			if (optionTicks.display) {
  				// Make sure we draw text in the correct color and font
  				context.save();
  				context.translate(itemToDraw.labelX, itemToDraw.labelY);
  				context.rotate(itemToDraw.rotation);
  				context.font = itemToDraw.major ? majorTickFont.string : tickFont.string;
  				context.fillStyle = itemToDraw.major ? majorTickFontColor : tickFontColor;
  				context.textBaseline = 'middle';
  				context.textAlign = itemToDraw.textAlign;
  
  				var label = itemToDraw.label;
  				var y = itemToDraw.textOffset;
  				if (helpers$1.isArray(label)) {
  					for (var i = 0; i < label.length; ++i) {
  						// We just make sure the multiline element is a string here..
  						context.fillText('' + label[i], 0, y);
  						y += lineHeight;
  					}
  				} else {
  					context.fillText(label, 0, y);
  				}
  				context.restore();
  			}
  		});
  
  		if (scaleLabel.display) {
  			// Draw the scale label
  			var scaleLabelX;
  			var scaleLabelY;
  			var rotation = 0;
  			var halfLineHeight = scaleLabelFont.lineHeight / 2;
  
  			if (isHorizontal) {
  				scaleLabelX = me.left + ((me.right - me.left) / 2); // midpoint of the width
  				scaleLabelY = position === 'bottom'
  					? me.bottom - halfLineHeight - scaleLabelPadding.bottom
  					: me.top + halfLineHeight + scaleLabelPadding.top;
  			} else {
  				var isLeft = position === 'left';
  				scaleLabelX = isLeft
  					? me.left + halfLineHeight + scaleLabelPadding.top
  					: me.right - halfLineHeight - scaleLabelPadding.top;
  				scaleLabelY = me.top + ((me.bottom - me.top) / 2);
  				rotation = isLeft ? -0.5 * Math.PI : 0.5 * Math.PI;
  			}
  
  			context.save();
  			context.translate(scaleLabelX, scaleLabelY);
  			context.rotate(rotation);
  			context.textAlign = 'center';
  			context.textBaseline = 'middle';
  			context.fillStyle = scaleLabelFontColor; // render in correct colour
  			context.font = scaleLabelFont.string;
  			context.fillText(scaleLabel.labelString, 0, 0);
  			context.restore();
  		}
  
  		if (axisWidth) {
  			// Draw the line at the edge of the axis
  			var firstLineWidth = axisWidth;
  			var lastLineWidth = valueAtIndexOrDefault(gridLines.lineWidth, ticks.length - 1, 0);
  			var x1, x2, y1, y2;
  
  			if (isHorizontal) {
  				x1 = alignPixel(chart, me.left, firstLineWidth) - firstLineWidth / 2;
  				x2 = alignPixel(chart, me.right, lastLineWidth) + lastLineWidth / 2;
  				y1 = y2 = borderValue;
  			} else {
  				y1 = alignPixel(chart, me.top, firstLineWidth) - firstLineWidth / 2;
  				y2 = alignPixel(chart, me.bottom, lastLineWidth) + lastLineWidth / 2;
  				x1 = x2 = borderValue;
  			}
  
  			context.lineWidth = axisWidth;
  			context.strokeStyle = valueAtIndexOrDefault(gridLines.color, 0);
  			context.beginPath();
  			context.moveTo(x1, y1);
  			context.lineTo(x2, y2);
  			context.stroke();
  		}
  	}