diff --git a/bower.json b/bower.json
new file mode 100644
index 0000000..15cdcda
--- /dev/null
+++ b/bower.json
@@ -0,0 +1,15 @@
+{
+  "name": "chartjs-plugin-rough",
+  "description": "Chart.js plugin to create charts with a hand-drawn, sketchy, appearance",
+  "homepage": "https://nagix.github.io/chartjs-plugin-rough",
+  "license": "MIT",
+  "version": "0.1.0",
+  "main": "./dist/chartjs-plugin-rough.js",
+  "ignore": [
+    ".codeclimate.yml",
+    ".gitignore",
+    ".npmignore",
+    ".travis.yml",
+    "scripts"
+  ]
+}
\ No newline at end of file
diff --git a/dist/chartjs-plugin-rough.js b/dist/chartjs-plugin-rough.js
new file mode 100644
index 0000000..eb02c1b
--- /dev/null
+++ b/dist/chartjs-plugin-rough.js
@@ -0,0 +1,1403 @@
+/*
+ * @license
+ * chartjs-plugin-rough
+ * https://github.com/nagix/chartjs-plugin-rough/
+ * Version: 0.1.0
+ *
+ * Copyright 2019 Akihiko Kusanagi
+ * Released under the MIT license
+ * https://github.com/nagix/chartjs-plugin-rough/blob/master/LICENSE.md
+ */
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('chart.js'), require('roughjs')) :
+	typeof define === 'function' && define.amd ? define(['chart.js', 'roughjs'], factory) :
+	(global.ChartRough = factory(global.Chart,global.rough));
+}(this, (function (Chart,rough) { 'use strict';
+
+Chart = Chart && Chart.hasOwnProperty('default') ? Chart['default'] : Chart;
+rough = rough && rough.hasOwnProperty('default') ? rough['default'] : rough;
+
+'use strict';
+
+var helpers = Chart.helpers;
+
+// For Chart.js 2.7.1 backward compatibility
+Chart.layouts = Chart.layouts || Chart.layoutService;
+
+// For Chart.js 2.7.3 backward compatibility
+helpers.canvas = helpers.canvas || {};
+helpers.canvas._isPointInArea = helpers.canvas._isPointInArea || function(point, area) {
+	var epsilon = 1e-6; // 1e-6 is margin in pixels for accumulated error.
+
+	return point.x > area.left - epsilon && point.x < area.right + epsilon &&
+		point.y > area.top - epsilon && point.y < area.bottom + epsilon;
+};
+
+'use strict';
+
+var PI = Math.PI;
+var RAD_PER_DEG = PI / 180;
+var QUARTER_PI = PI / 4;
+var TWO_THIRDS_PI = PI * 2 / 3;
+
+var roughHelpers = {
+
+	roughKeys: [
+		'roughness',
+		'bowing',
+		'fillStyle',
+		'fillWeight',
+		'hachureAngle',
+		'hachureGap',
+		'curveStepCount',
+		'simplification'
+	],
+
+	drawPoint: function(ctx, style, radius, x, y, rotation, canvas, options) {
+		var fillOpts = this.getFillOptions(options);
+		var strokeOpts = this.getStrokeOptions(options);
+		var rad = (rotation || 0) * RAD_PER_DEG;
+		var type, xOffset, yOffset, xCornerOffset, yCornerOffset, size, cornerRadius, vertices, path, arcPrefix;
+
+		if (style && typeof style === 'object') {
+			type = style.toString();
+			if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {
+				ctx.drawImage(style, x - style.width / 2, y - style.height / 2, style.width, style.height);
+				return;
+			}
+		}
+
+		if (isNaN(radius) || radius <= 0) {
+			return;
+		}
+
+		switch (style) {
+		// Default includes circle
+		default:
+			canvas.circle(x, y, radius * 2, fillOpts);
+			canvas.circle(x, y, radius * 2, strokeOpts);
+			break;
+		case 'triangle':
+			vertices = [];
+			vertices.push([x + Math.sin(rad) * radius, y - Math.cos(rad) * radius]);
+			rad += TWO_THIRDS_PI;
+			vertices.push([x + Math.sin(rad) * radius, y - Math.cos(rad) * radius]);
+			rad += TWO_THIRDS_PI;
+			vertices.push([x + Math.sin(rad) * radius, y - Math.cos(rad) * radius]);
+			canvas.polygon(vertices, fillOpts);
+			canvas.polygon(vertices, strokeOpts);
+			break;
+		case 'rectRounded':
+			cornerRadius = radius * 0.516;
+			xCornerOffset = Math.cos(rad) * cornerRadius;
+			yCornerOffset = Math.sin(rad) * cornerRadius;
+			rad += QUARTER_PI;
+			size = radius - cornerRadius;
+			xOffset = Math.cos(rad) * size;
+			yOffset = Math.sin(rad) * size;
+			arcPrefix = 'A' + cornerRadius + ' ' + cornerRadius + ' 0 0 1 ';
+			path =
+				'M' + (x - xOffset - xCornerOffset) + ' ' + (y - yOffset - yCornerOffset) +
+				arcPrefix + (x - xOffset + yCornerOffset) + ' ' + (y - yOffset - xCornerOffset) +
+				'L' + (x + yOffset + yCornerOffset) + ' ' + (y - xOffset - xCornerOffset) +
+				arcPrefix + (x + yOffset + xCornerOffset) + ' ' + (y - xOffset + yCornerOffset) +
+				'L' + (x + xOffset + xCornerOffset) + ' ' + (y + yOffset + yCornerOffset) +
+				arcPrefix + (x + xOffset - yCornerOffset) + ' ' + (y + yOffset + xCornerOffset) +
+				'L' + (x - yOffset - yCornerOffset) + ' ' + (y + xOffset + xCornerOffset) +
+				arcPrefix + (x - yOffset - xCornerOffset) + ' ' + (y + xOffset - yCornerOffset) + 'Z';
+			canvas.path(path, fillOpts);
+			canvas.path(path, strokeOpts);
+			break;
+		case 'rect':
+			if (!rotation) {
+				size = Math.SQRT1_2 * radius;
+				canvas.rectangle(x - size, y - size, 2 * size, 2 * size, fillOpts);
+				canvas.rectangle(x - size, y - size, 2 * size, 2 * size, strokeOpts);
+				break;
+			}
+			rad += QUARTER_PI;
+			/* falls through */
+		case 'rectRot':
+			xOffset = Math.cos(rad) * radius;
+			yOffset = Math.sin(rad) * radius;
+			vertices = [
+				[x - xOffset, y - yOffset],
+				[x + yOffset, y - xOffset],
+				[x + xOffset, y + yOffset],
+				[x - yOffset, y + xOffset]
+			];
+			canvas.polygon(vertices, fillOpts);
+			canvas.polygon(vertices, strokeOpts);
+			break;
+		case 'crossRot':
+			rad += QUARTER_PI;
+			/* falls through */
+		case 'cross':
+			xOffset = Math.cos(rad) * radius;
+			yOffset = Math.sin(rad) * radius;
+			canvas.line(x - xOffset, y - yOffset, x + xOffset, y + yOffset, strokeOpts);
+			canvas.line(x + yOffset, y - xOffset, x - yOffset, y + xOffset, strokeOpts);
+			break;
+		case 'star':
+			xOffset = Math.cos(rad) * radius;
+			yOffset = Math.sin(rad) * radius;
+			canvas.line(x - xOffset, y - yOffset, x + xOffset, y + yOffset, strokeOpts);
+			canvas.line(x + yOffset, y - xOffset, x - yOffset, y + xOffset, strokeOpts);
+			rad += QUARTER_PI;
+			xOffset = Math.cos(rad) * radius;
+			yOffset = Math.sin(rad) * radius;
+			canvas.line(x - xOffset, y - yOffset, x + xOffset, y + yOffset, strokeOpts);
+			canvas.line(x + yOffset, y - xOffset, x - yOffset, y + xOffset, strokeOpts);
+			break;
+		case 'line':
+			xOffset = Math.cos(rad) * radius;
+			yOffset = Math.sin(rad) * radius;
+			canvas.line(x - xOffset, y - yOffset, x + xOffset, y + yOffset, strokeOpts);
+			break;
+		case 'dash':
+			canvas.line(x, y, x + Math.cos(rad) * radius, y + Math.sin(rad) * radius, strokeOpts);
+			break;
+		}
+	},
+
+	lineTo: function(previous, target, flip) {
+		var stepped = target.steppedLine;
+		var midpoint, path;
+
+		if (stepped) {
+			if (stepped === 'middle') {
+				midpoint = (previous.x + target.x) / 2;
+				path = 'L' + midpoint + ' ' + (flip ? target.y : previous.y) +
+					'L' + midpoint + ' ' + (flip ? previous.y : target.y);
+			} else if ((stepped === 'after' && !flip) || (stepped !== 'after' && flip)) {
+				path = 'L' + previous.x + ' ' + target.y;
+			} else {
+				path = 'L' + target.x + ' ' + previous.y;
+			}
+			return path + 'L' + target.x + ' ' + target.y;
+		}
+
+		if (!target.tension) {
+			return 'L' + target.x + ' ' + target.y;
+		}
+
+		return 'C ' +
+			(flip ? previous.controlPointPreviousX : previous.controlPointNextX) + ' ' +
+			(flip ? previous.controlPointPreviousY : previous.controlPointNextY) + ',' +
+			(flip ? target.controlPointNextX : target.controlPointPreviousX) + ' ' +
+			(flip ? target.controlPointNextY : target.controlPointPreviousY) + ',' +
+			target.x + ' ' + target.y;
+	},
+
+	resolve: function(dataset, options) {
+		var override = dataset.rough;
+
+		if (override === false) {
+			return null;
+		}
+		if (override === true) {
+			override = {};
+		}
+
+		return Chart.helpers.merge({}, [options, override]);
+	},
+
+	getFillOptions: function(options) {
+		var values = {
+			stroke: 'transparent',
+			fill: options.backgroundColor
+		};
+
+		this.roughKeys.forEach(function(key) {
+			if (options[key] !== undefined) {
+				values[key] = options[key];
+			}
+		});
+		return values;
+	},
+
+	getStrokeOptions: function(options) {
+		var keys = ['roughness', 'bowing', 'curveStepCount', 'simplification'];
+		var values = {
+			stroke: options.borderColor,
+			strokeWidth: options.borderWidth
+		};
+
+		keys.forEach(function(key) {
+			if (options[key] !== undefined) {
+				values[key] = options[key];
+			}
+		});
+		return values;
+	}
+};
+
+'use strict';
+
+var Arc = Chart.elements.Arc;
+
+var RoughArc = Arc.extend({
+
+	// Ported from Chart.js 2.7.3. Modified for rough arc.
+	draw: function() {
+		var vm = this._view;
+		var x = vm.x;
+		var y = vm.y;
+		var outerRadius = vm.outerRadius;
+		var innerRadius = vm.innerRadius;
+		var sA = vm.startAngle;
+		var eA = vm.endAngle;
+		var sCos = Math.cos(sA);
+		var sSin = Math.sin(sA);
+		var eCos = Math.cos(eA);
+		var eSin = Math.sin(eA);
+		var isLargeArc = eA - sA > Math.PI ? 1 : 0;
+		var canvas = rough.canvas(this._chart.canvas);
+
+		var path =
+			'M' + (x + outerRadius * sCos) + ' ' + (y + outerRadius * sSin) +
+			'A' + outerRadius + ' ' + outerRadius + ' 0 ' + isLargeArc +
+			' 1 ' + (x + outerRadius * eCos) + ' ' + (y + outerRadius * eSin) +
+			'L' + (x + innerRadius * eCos) + ' ' + (y + innerRadius * eSin) +
+			'A' + innerRadius + ' ' + innerRadius + ' 0 ' + isLargeArc +
+			' 0 ' + (x + innerRadius * sCos) + ' ' + (y + innerRadius * sSin) + 'Z';
+
+		canvas.path(path, roughHelpers.getFillOptions(vm));
+
+		if (vm.borderWidth) {
+			canvas.path(path, roughHelpers.getStrokeOptions(vm));
+		}
+	}
+});
+
+'use strict';
+
+var Line = Chart.elements.Line;
+
+var RoughLine = Line.extend({
+
+	// Ported from Chart.js 2.7.3. Modified for rough line.
+	draw: function() {
+		var me = this;
+		var vm = me._view;
+		var spanGaps = vm.spanGaps;
+		var points = me._children.slice(); // clone array
+		var lastDrawnIndex = -1;
+		var index, current, previous, currentVM;
+		var canvas = rough.canvas(this._chart.canvas);
+		var path = '';
+
+		// If we are looping, adding the first point again
+		if (me._loop && points.length) {
+			points.push(points[0]);
+		}
+
+		// Stroke Line
+		lastDrawnIndex = -1;
+
+		for (index = 0; index < points.length; ++index) {
+			current = points[index];
+			previous = Chart.helpers.previousItem(points, index);
+			currentVM = current._view;
+
+			// First point moves to it's starting position no matter what
+			if (index === 0) {
+				if (!currentVM.skip) {
+					path += 'M' + currentVM.x + ' ' + currentVM.y;
+					lastDrawnIndex = index;
+				}
+			} else {
+				previous = lastDrawnIndex === -1 ? previous : points[lastDrawnIndex];
+
+				if (!currentVM.skip) {
+					if ((lastDrawnIndex !== (index - 1) && !spanGaps) || lastDrawnIndex === -1) {
+						// There was a gap and this is the first point after the gap
+						path += 'M' + currentVM.x + ' ' + currentVM.y;
+					} else {
+						// Line to next point
+						path += roughHelpers.lineTo(previous._view, current._view);
+					}
+					lastDrawnIndex = index;
+				}
+			}
+		}
+
+		canvas.path(path, roughHelpers.getStrokeOptions(vm));
+	}
+});
+
+'use strict';
+
+var Arc$1 = Chart.elements.Point;
+
+var RoughPoint = Arc$1.extend({
+
+	// Ported from Chart.js 2.7.3. Modified for rough point.
+	draw: function(chartArea) {
+		var me = this;
+		var vm = me._view;
+		var chart = me._chart;
+		var ctx = chart.ctx;
+		var canvas = rough.canvas(chart.canvas);
+
+		if (vm.skip) {
+			return;
+		}
+
+		// Clipping for Points.
+		if (chartArea === undefined || Chart.helpers.canvas._isPointInArea(vm, chartArea)) {
+			roughHelpers.drawPoint(ctx, vm.pointStyle, vm.radius, vm.x, vm.y, vm.rotation, canvas, vm);
+		}
+	}
+});
+
+'use strict';
+
+var Rectangle = Chart.elements.Rectangle;
+
+var RoughRectangle = Rectangle.extend({
+
+	// Ported from Chart.js 2.7.3. Modified for rough rectangle.
+	draw: function() {
+		var me = this;
+		var vm = me._view;
+		var left, right, top, bottom, signX, signY, borderSkipped;
+		var borderWidth = vm.borderWidth;
+		var canvas = rough.canvas(me._chart.canvas);
+
+		if (!vm.horizontal) {
+			// bar
+			left = vm.x - vm.width / 2;
+			right = vm.x + vm.width / 2;
+			top = vm.y;
+			bottom = vm.base;
+			signX = 1;
+			signY = bottom > top ? 1 : -1;
+			borderSkipped = vm.borderSkipped || 'bottom';
+		} else {
+			// horizontal bar
+			left = vm.base;
+			right = vm.x;
+			top = vm.y - vm.height / 2;
+			bottom = vm.y + vm.height / 2;
+			signX = right > left ? 1 : -1;
+			signY = 1;
+			borderSkipped = vm.borderSkipped || 'left';
+		}
+
+		// Canvas doesn't allow us to stroke inside the width so we can
+		// adjust the sizes to fit if we're setting a stroke on the line
+		if (borderWidth) {
+			// borderWidth shold be less than bar width and bar height.
+			var barSize = Math.min(Math.abs(left - right), Math.abs(top - bottom));
+			borderWidth = borderWidth > barSize ? barSize : borderWidth;
+			var halfStroke = borderWidth / 2;
+			// Adjust borderWidth when bar top position is near vm.base(zero).
+			var borderLeft = left + (borderSkipped !== 'left' ? halfStroke * signX : 0);
+			var borderRight = right + (borderSkipped !== 'right' ? -halfStroke * signX : 0);
+			var borderTop = top + (borderSkipped !== 'top' ? halfStroke * signY : 0);
+			var borderBottom = bottom + (borderSkipped !== 'bottom' ? -halfStroke * signY : 0);
+			// not become a vertical line?
+			if (borderLeft !== borderRight) {
+				top = borderTop;
+				bottom = borderBottom;
+			}
+			// not become a horizontal line?
+			if (borderTop !== borderBottom) {
+				left = borderLeft;
+				right = borderRight;
+			}
+		}
+
+		// Corner points, from bottom-left to bottom-right clockwise
+		// | 1 2 |
+		// | 0 3 |
+		var corners = [
+			[left, bottom],
+			[left, top],
+			[right, top],
+			[right, bottom]
+		];
+
+		// Find first (starting) corner with fallback to 'bottom'
+		var borders = ['bottom', 'left', 'top', 'right'];
+		var startCorner = borders.indexOf(borderSkipped, 0);
+		if (startCorner === -1) {
+			startCorner = 0;
+		}
+
+		function cornerAt(index) {
+			return corners[(startCorner + index) % 4];
+		}
+
+		canvas.rectangle(
+			corners[1][0], corners[1][1], corners[3][0] - corners[1][0], corners[3][1] - corners[1][1],
+			roughHelpers.getFillOptions(vm));
+
+		if (borderWidth) {
+			var corner = cornerAt(0);
+			for (var i = 1; i < 4; i++) {
+				var nextCorner = cornerAt(i);
+				canvas.line(corner[0], corner[1], nextCorner[0], nextCorner[1], roughHelpers.getStrokeOptions(vm));
+				corner = nextCorner;
+			}
+		}
+	}
+});
+
+'use strict';
+
+var helpers$1 = Chart.helpers;
+
+var resolve = helpers$1.options.resolve;
+
+var BarController = Chart.controllers.bar;
+
+var RoughBarController = BarController.extend({
+
+	dataElementType: RoughRectangle,
+
+	// Ported from Chart.js 2.7.3. Modified for rough bar.
+	updateElement: function(rectangle, index, reset) {
+		var me = this;
+		var chart = me.chart;
+		var meta = me.getMeta();
+		var dataset = me.getDataset();
+		var custom = rectangle.custom || {};
+		var options = chart.options;
+		var rectangleOptions = options.elements.rectangle;
+
+		rectangle._xScale = me.getScaleForId(meta.xAxisID);
+		rectangle._yScale = me.getScaleForId(meta.yAxisID);
+		rectangle._datasetIndex = me.index;
+		rectangle._index = index;
+
+		rectangle._model = helpers$1.merge({
+			datasetLabel: dataset.label,
+			label: chart.data.labels[index],
+			borderSkipped: helpers$1.valueOrDefault(custom.borderSkipped, rectangleOptions.borderSkipped),
+			backgroundColor: resolve([custom.backgroundColor, dataset.backgroundColor, rectangleOptions.backgroundColor], undefined, index),
+			borderColor: resolve([custom.borderColor, dataset.borderColor, rectangleOptions.borderColor], undefined, index),
+			borderWidth: resolve([custom.borderWidth, dataset.borderWidth, rectangleOptions.borderWidth], undefined, index)
+		}, roughHelpers.resolve(dataset, options.plugins.rough));
+
+		me.updateElementGeometry(rectangle, index, reset);
+
+		rectangle.pivot();
+	}
+});
+
+'use strict';
+
+var BubbleController = Chart.controllers.bubble;
+
+var RoughBubbleController = BubbleController.extend({
+
+	dataElementType: RoughPoint,
+
+	/**
+	 * Ported from Chart.js 2.7.3. Modified for rough bubble.
+	 * @protected
+	 */
+	updateElement: function(point, index, reset) {
+		var me = this;
+		var meta = me.getMeta();
+		var custom = point.custom || {};
+		var xScale = me.getScaleForId(meta.xAxisID);
+		var yScale = me.getScaleForId(meta.yAxisID);
+		var options = me._resolveElementOptions(point, index);
+		var data = me.getDataset().data[index];
+		var dsIndex = me.index;
+
+		var x = reset ? xScale.getPixelForDecimal(0.5) : xScale.getPixelForValue(typeof data === 'object' ? data : NaN, index, dsIndex);
+		var y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(data, index, dsIndex);
+
+		point._xScale = xScale;
+		point._yScale = yScale;
+		point._options = options;
+		point._datasetIndex = dsIndex;
+		point._index = index;
+		point._model = Chart.helpers.merge({
+			backgroundColor: options.backgroundColor,
+			borderColor: options.borderColor,
+			borderWidth: options.borderWidth,
+			hitRadius: options.hitRadius,
+			pointStyle: options.pointStyle,
+			rotation: options.rotation,
+			radius: reset ? 0 : options.radius,
+			skip: custom.skip || isNaN(x) || isNaN(y),
+			x: x,
+			y: y
+		}, roughHelpers.resolve(me.getDataset(), me.chart.options.plugins.rough));
+
+		point.pivot();
+	}
+});
+
+'use strict';
+
+var defaults = Chart.defaults;
+var helpers$2 = Chart.helpers;
+
+var resolve$1 = helpers$2.options.resolve;
+
+// Ported from Chart.js 2.7.3. Modified for rough doughnut.
+defaults.doughnut.legend.labels.generateLabels = defaults.pie.legend.labels.generateLabels = function(chart) {
+	var data = chart.data;
+	if (data.labels.length && data.datasets.length) {
+		return data.labels.map(function(label, i) {
+			var meta = chart.getDatasetMeta(0);
+			var ds = data.datasets[0];
+			var arc = meta.data[i];
+			var custom = arc && arc.custom || {};
+			var options = chart.options;
+			var arcOpts = options.elements.arc;
+			var fill = resolve$1([custom.backgroundColor, ds.backgroundColor, arcOpts.backgroundColor], undefined, i);
+			var stroke = resolve$1([custom.borderColor, ds.borderColor, arcOpts.borderColor], undefined, i);
+			var bw = resolve$1([custom.borderWidth, ds.borderWidth, arcOpts.borderWidth], undefined, i);
+
+			return {
+				text: label,
+				fillStyle: fill,
+				strokeStyle: stroke,
+				lineWidth: bw,
+				hidden: isNaN(ds.data[i]) || meta.data[i].hidden,
+				rough: roughHelpers.resolve(ds, options.plugins.rough),
+
+				// Extra data used for toggling the correct item
+				index: i
+			};
+		});
+	}
+	return [];
+};
+
+var DoughnutController = Chart.controllers.doughnut;
+
+var RoughDoughnutController = DoughnutController.extend({
+
+	dataElementType: RoughArc,
+
+	// Ported from Chart.js 2.7.3. Modified for rough doughnut.
+	updateElement: function(arc, index, reset) {
+		var me = this;
+		var chart = me.chart;
+		var chartArea = chart.chartArea;
+		var opts = chart.options;
+		var animationOpts = opts.animation;
+		var centerX = (chartArea.left + chartArea.right) / 2;
+		var centerY = (chartArea.top + chartArea.bottom) / 2;
+		var startAngle = opts.rotation; // non reset case handled later
+		var endAngle = opts.rotation; // non reset case handled later
+		var dataset = me.getDataset();
+		var circumference = reset && animationOpts.animateRotate ? 0 : arc.hidden ? 0 : me.calculateCircumference(dataset.data[index]) * (opts.circumference / (2.0 * Math.PI));
+		var innerRadius = reset && animationOpts.animateScale ? 0 : me.innerRadius;
+		var outerRadius = reset && animationOpts.animateScale ? 0 : me.outerRadius;
+
+		helpers$2.extend(arc, {
+			// Utility
+			_datasetIndex: me.index,
+			_index: index,
+
+			// Desired view properties
+			_model: {
+				x: centerX + chart.offsetX,
+				y: centerY + chart.offsetY,
+				startAngle: startAngle,
+				endAngle: endAngle,
+				circumference: circumference,
+				outerRadius: outerRadius,
+				innerRadius: innerRadius,
+				label: helpers$2.valueAtIndexOrDefault(dataset.label, index, chart.data.labels[index])
+			}
+		});
+
+		var model = arc._model;
+
+		// Resets the visual styles
+		var custom = arc.custom || {};
+		var elementOpts = opts.elements.arc;
+		model.backgroundColor = resolve$1([custom.backgroundColor, dataset.backgroundColor, elementOpts.backgroundColor], undefined, index);
+		model.borderColor = resolve$1([custom.borderColor, dataset.borderColor, elementOpts.borderColor], undefined, index);
+		model.borderWidth = resolve$1([custom.borderWidth, dataset.borderWidth, elementOpts.borderWidth], undefined, index);
+
+		helpers$2.merge(model, roughHelpers.resolve(dataset, opts.plugins.rough));
+
+		// Set correct angles if not resetting
+		if (!reset || !animationOpts.animateRotate) {
+			if (index === 0) {
+				model.startAngle = opts.rotation;
+			} else {
+				model.startAngle = me.getMeta().data[index - 1]._model.endAngle;
+			}
+
+			model.endAngle = model.startAngle + model.circumference;
+		}
+
+		arc.pivot();
+	}
+});
+
+'use strict';
+
+var RoughHorizontalBarController = RoughBarController.extend({
+	/**
+	 * @private
+	 */
+	getValueScaleId: function() {
+		return this.getMeta().xAxisID;
+	},
+
+	/**
+	 * @private
+	 */
+	getIndexScaleId: function() {
+		return this.getMeta().yAxisID;
+	}
+});
+
+'use strict';
+
+var helpers$3 = Chart.helpers;
+
+var valueOrDefault = helpers$3.valueOrDefault;
+var resolve$2 = helpers$3.options.resolve;
+
+var LineController = Chart.controllers.line;
+
+// Ported from Chart.js 2.7.3.
+function lineEnabled(dataset, options) {
+	return valueOrDefault(dataset.showLine, options.showLines);
+}
+
+var RoughLineController = LineController.extend({
+
+	datasetElementType: RoughLine,
+
+	dataElementType: RoughPoint,
+
+	// Ported from Chart.js 2.7.3. Modified for rough line.
+	update: function(reset) {
+		var me = this;
+		var meta = me.getMeta();
+		var line = meta.dataset;
+		var points = meta.data || [];
+		var options = me.chart.options;
+		var lineElementOptions = options.elements.line;
+		var scale = me.getScaleForId(meta.yAxisID);
+		var i, ilen, custom;
+		var dataset = me.getDataset();
+		var showLine = lineEnabled(dataset, options);
+
+		// Update Line
+		if (showLine) {
+			custom = line.custom || {};
+
+			// Compatibility: If the properties are defined with only the old name, use those values
+			if ((dataset.tension !== undefined) && (dataset.lineTension === undefined)) {
+				dataset.lineTension = dataset.tension;
+			}
+
+			// Utility
+			line._scale = scale;
+			line._datasetIndex = me.index;
+			// Data
+			line._children = points;
+			// Model
+			line._model = helpers$3.merge({
+				// Appearance
+				// The default behavior of lines is to break at null values, according
+				// to https://github.com/chartjs/Chart.js/issues/2435#issuecomment-216718158
+				// This option gives lines the ability to span gaps
+				spanGaps: valueOrDefault(dataset.spanGaps, options.spanGaps),
+				tension: resolve$2([custom.tension, dataset.lineTension, lineElementOptions.tension]),
+				backgroundColor: resolve$2([custom.backgroundColor, dataset.backgroundColor, lineElementOptions.backgroundColor]),
+				borderWidth: resolve$2([custom.borderWidth, dataset.borderWidth, lineElementOptions.borderWidth]),
+				borderColor: resolve$2([custom.borderColor, dataset.borderColor, lineElementOptions.borderColor]),
+				borderCapStyle: resolve$2([custom.borderCapStyle, dataset.borderCapStyle, lineElementOptions.borderCapStyle]),
+				borderDash: resolve$2([custom.borderDash, dataset.borderDash, lineElementOptions.borderDash]),
+				borderDashOffset: resolve$2([custom.borderDashOffset, dataset.borderDashOffset, lineElementOptions.borderDashOffset]),
+				borderJoinStyle: resolve$2([custom.borderJoinStyle, dataset.borderJoinStyle, lineElementOptions.borderJoinStyle]),
+				fill: resolve$2([custom.fill, dataset.fill, lineElementOptions.fill]),
+				steppedLine: resolve$2([custom.steppedLine, dataset.steppedLine, lineElementOptions.stepped]),
+				cubicInterpolationMode: resolve$2([custom.cubicInterpolationMode, dataset.cubicInterpolationMode, lineElementOptions.cubicInterpolationMode])
+			}, roughHelpers.resolve(dataset, options.plugins.rough));
+
+			line.pivot();
+		}
+
+		// Update Points
+		for (i = 0, ilen = points.length; i < ilen; ++i) {
+			me.updateElement(points[i], i, reset);
+		}
+
+		if (showLine && line._model.tension !== 0) {
+			me.updateBezierControlPoints();
+		}
+
+		// Now pivot the point for animation
+		for (i = 0, ilen = points.length; i < ilen; ++i) {
+			points[i].pivot();
+		}
+	},
+
+	updateElement: function(point) {
+		var me = this;
+
+		LineController.prototype.updateElement.apply(me, arguments);
+
+		helpers$3.merge(point._model, roughHelpers.resolve(me.getDataset(), me.chart.options.plugins.rough));
+	}
+});
+
+'use strict';
+
+var helpers$4 = Chart.helpers;
+
+var resolve$3 = helpers$4.options.resolve;
+
+// Ported from Chart.js 2.7.3. Modified for rough polarArea.
+Chart.defaults.polarArea.legend.labels.generateLabels = function(chart) {
+	var data = chart.data;
+	if (data.labels.length && data.datasets.length) {
+		return data.labels.map(function(label, i) {
+			var meta = chart.getDatasetMeta(0);
+			var ds = data.datasets[0];
+			var arc = meta.data[i];
+			var custom = arc.custom || {};
+			var options = chart.options;
+			var arcOpts = options.elements.arc;
+			var fill = resolve$3([custom.backgroundColor, ds.backgroundColor, arcOpts.backgroundColor], undefined, i);
+			var stroke = resolve$3([custom.borderColor, ds.borderColor, arcOpts.borderColor], undefined, i);
+			var bw = resolve$3([custom.borderWidth, ds.borderWidth, arcOpts.borderWidth], undefined, i);
+
+			return {
+				text: label,
+				fillStyle: fill,
+				strokeStyle: stroke,
+				lineWidth: bw,
+				hidden: isNaN(ds.data[i]) || meta.data[i].hidden,
+				rough: roughHelpers.resolve(ds, options.plugins.rough),
+
+				// Extra data used for toggling the correct item
+				index: i
+			};
+		});
+	}
+	return [];
+};
+
+var PolarAreaController = Chart.controllers.polarArea;
+
+var RoughPolarAreaController = PolarAreaController.extend({
+
+	dataElementType: RoughArc,
+
+	// Ported from Chart.js 2.7.3. Modified for rough polarArea.
+	updateElement: function(arc, index, reset) {
+		var me = this;
+		var chart = me.chart;
+		var dataset = me.getDataset();
+		var opts = chart.options;
+		var animationOpts = opts.animation;
+		var scale = chart.scale;
+		var labels = chart.data.labels;
+
+		var centerX = scale.xCenter;
+		var centerY = scale.yCenter;
+
+		// var negHalfPI = -0.5 * Math.PI;
+		var datasetStartAngle = opts.startAngle;
+		var distance = arc.hidden ? 0 : scale.getDistanceFromCenterForValue(dataset.data[index]);
+
+		// For Chart.js 2.7.2 backward compatibility
+		var startAngle, endAngle;
+		if (me.calculateCircumference) {
+			var circumference = me.calculateCircumference(dataset.data[index]);
+
+			// If there is NaN data before us, we need to calculate the starting angle correctly.
+			// We could be way more efficient here, but its unlikely that the polar area chart will have a lot of data
+			var visibleCount = 0;
+			var meta = me.getMeta();
+			for (var i = 0; i < index; ++i) {
+				if (!isNaN(dataset.data[i]) && !meta.data[i].hidden) {
+					++visibleCount;
+				}
+			}
+
+			startAngle = datasetStartAngle + (circumference * visibleCount);
+			endAngle = startAngle + (arc.hidden ? 0 : circumference);
+		} else {
+			startAngle = me._starts[index];
+			endAngle = startAngle + (arc.hidden ? 0 : me._angles[index]);
+		}
+
+		var resetRadius = animationOpts.animateScale ? 0 : scale.getDistanceFromCenterForValue(dataset.data[index]);
+
+		helpers$4.extend(arc, {
+			// Utility
+			_datasetIndex: me.index,
+			_index: index,
+			_scale: scale,
+
+			// Desired view properties
+			_model: {
+				x: centerX,
+				y: centerY,
+				innerRadius: 0,
+				outerRadius: reset ? resetRadius : distance,
+				startAngle: reset && animationOpts.animateRotate ? datasetStartAngle : startAngle,
+				endAngle: reset && animationOpts.animateRotate ? datasetStartAngle : endAngle,
+				label: helpers$4.valueAtIndexOrDefault(labels, index, labels[index])
+			}
+		});
+
+		// Apply border and fill style
+		var elementOpts = opts.elements.arc;
+		var custom = arc.custom || {};
+		var model = arc._model;
+
+		model.backgroundColor = resolve$3([custom.backgroundColor, dataset.backgroundColor, elementOpts.backgroundColor], undefined, index);
+		model.borderColor = resolve$3([custom.borderColor, dataset.borderColor, elementOpts.borderColor], undefined, index);
+		model.borderWidth = resolve$3([custom.borderWidth, dataset.borderWidth, elementOpts.borderWidth], undefined, index);
+
+		helpers$4.merge(model, roughHelpers.resolve(dataset, opts.plugins.rough));
+
+		arc.pivot();
+	}
+});
+
+'use strict';
+
+var helpers$5 = Chart.helpers;
+
+var resolve$4 = helpers$5.options.resolve;
+
+var RadarController = Chart.controllers.radar;
+
+var RoughRadarController = RadarController.extend({
+
+	datasetElementType: RoughLine,
+
+	dataElementType: RoughPoint,
+
+	// Ported from Chart.js 2.7.3. Modified for rough radar.
+	update: function(reset) {
+		var me = this;
+		var meta = me.getMeta();
+		var line = meta.dataset;
+		var points = meta.data;
+		var custom = line.custom || {};
+		var dataset = me.getDataset();
+		var options = me.chart.options;
+		var lineElementOptions = options.elements.line;
+		var scale = me.chart.scale;
+
+		// Compatibility: If the properties are defined with only the old name, use those values
+		if ((dataset.tension !== undefined) && (dataset.lineTension === undefined)) {
+			dataset.lineTension = dataset.tension;
+		}
+
+		helpers$5.extend(meta.dataset, {
+			// Utility
+			_datasetIndex: me.index,
+			_scale: scale,
+			// Data
+			_children: points,
+			_loop: true,
+			// Model
+			_model: helpers$5.merge({
+				// Appearance
+				tension: resolve$4([custom.tension, dataset.lineTension, lineElementOptions.tension]),
+				backgroundColor: resolve$4([custom.backgroundColor, dataset.backgroundColor, lineElementOptions.backgroundColor]),
+				borderWidth: resolve$4([custom.borderWidth, dataset.borderWidth, lineElementOptions.borderWidth]),
+				borderColor: resolve$4([custom.borderColor, dataset.borderColor, lineElementOptions.borderColor]),
+				fill: resolve$4([custom.fill, dataset.fill, lineElementOptions.fill]),
+				borderCapStyle: resolve$4([custom.borderCapStyle, dataset.borderCapStyle, lineElementOptions.borderCapStyle]),
+				borderDash: resolve$4([custom.borderDash, dataset.borderDash, lineElementOptions.borderDash]),
+				borderDashOffset: resolve$4([custom.borderDashOffset, dataset.borderDashOffset, lineElementOptions.borderDashOffset]),
+				borderJoinStyle: resolve$4([custom.borderJoinStyle, dataset.borderJoinStyle, lineElementOptions.borderJoinStyle])
+			}, roughHelpers.resolve(dataset, options.plugins.rough))
+		});
+
+		meta.dataset.pivot();
+
+		// Update Points
+		helpers$5.each(points, function(point, index) {
+			me.updateElement(point, index, reset);
+		}, me);
+
+		// Update bezier control points
+		me.updateBezierControlPoints();
+	},
+
+	updateElement: function(point) {
+		var me = this;
+
+		RadarController.prototype.updateElement.apply(me, arguments);
+
+		helpers$5.merge(point._model, roughHelpers.resolve(me.getDataset(), me.chart.options.plugins.rough));
+	}
+});
+
+'use strict';
+
+var helpers$6 = Chart.helpers;
+
+var FillerPlugin = Chart.plugins.getAll().filter(function(plugin) {
+	return plugin.id === 'filler';
+})[0];
+
+// Ported from Chart.js 2.7.3.
+function isDrawable(point) {
+	return point && !point.skip;
+}
+
+// Ported from Chart.js 2.7.3. Modified for rough filler.
+function drawArea(curve0, curve1, len0, len1) {
+	var path, i;
+
+	if (!len0 || !len1) {
+		return;
+	}
+
+	// building first area curve (normal)
+	path = 'M' + curve0[0].x + ' ' + curve0[0].y;
+	for (i = 1; i < len0; ++i) {
+		path += roughHelpers.lineTo(curve0[i - 1], curve0[i]);
+	}
+
+	// joining the two area curves
+	path += 'L' + curve1[len1 - 1].x + ' ' + curve1[len1 - 1].y;
+
+	// building opposite area curve (reverse)
+	for (i = len1 - 1; i > 0; --i) {
+		path += roughHelpers.lineTo(curve1[i], curve1[i - 1], true);
+	}
+
+	return path;
+}
+
+// Ported from Chart.js 2.7.3. Modified for rough filler.
+function doFill(chart, points, mapper, view, color, loop) {
+	var count = points.length;
+	var span = view.spanGaps;
+	var curve0 = [];
+	var curve1 = [];
+	var len0 = 0;
+	var len1 = 0;
+	var canvas = rough.canvas(chart.canvas);
+	var path = '';
+	var i, ilen, index, p0, p1, d0, d1;
+
+	for (i = 0, ilen = (count + !!loop); i < ilen; ++i) {
+		index = i % count;
+		p0 = points[index]._view;
+		p1 = mapper(p0, index, view);
+		d0 = isDrawable(p0);
+		d1 = isDrawable(p1);
+
+		if (d0 && d1) {
+			len0 = curve0.push(p0);
+			len1 = curve1.push(p1);
+		} else if (len0 && len1) {
+			if (!span) {
+				path += drawArea(curve0, curve1, len0, len1);
+				len0 = len1 = 0;
+				curve0 = [];
+				curve1 = [];
+			} else {
+				if (d0) {
+					curve0.push(p0);
+				}
+				if (d1) {
+					curve1.push(p1);
+				}
+			}
+		}
+	}
+
+	path += drawArea(curve0, curve1, len0, len1);
+
+	canvas.path(path, roughHelpers.getFillOptions(view));
+}
+
+var RoughFillerPlugin = helpers$6.merge({}, [FillerPlugin, {
+	// Ported from Chart.js 2.7.3.
+	beforeDatasetDraw: function(chart, args) {
+		var meta = args.meta.$filler;
+		if (!meta) {
+			return;
+		}
+
+		var ctx = chart.ctx;
+		var el = meta.el;
+		var view = el._view;
+		var points = el._children || [];
+		var mapper = meta.mapper;
+		var color = view.backgroundColor || Chart.defaults.global.defaultColor;
+
+		if (mapper && color && points.length) {
+			helpers$6.canvas.clipArea(ctx, chart.chartArea);
+			doFill(chart, points, mapper, view, color, el._loop);
+			helpers$6.canvas.unclipArea(ctx);
+		}
+	}
+}]);
+
+'use strict';
+
+var defaults$1 = Chart.defaults;
+var helpers$7 = Chart.helpers;
+var layouts = Chart.layouts;
+
+var isArray = helpers$7.isArray;
+var valueOrDefault$1 = helpers$7.valueOrDefault;
+
+// Ported from Chart.js 2.7.3. Modified for rough legend.
+// Generates labels shown in the legend
+defaults$1.global.legend.labels.generateLabels = function(chart) {
+	var data = chart.data;
+	return isArray(data.datasets) ? data.datasets.map(function(dataset, i) {
+		return {
+			text: dataset.label,
+			fillStyle: helpers$7.valueAtIndexOrDefault(dataset.backgroundColor, 0),
+			hidden: !chart.isDatasetVisible(i),
+			lineCap: dataset.borderCapStyle,
+			lineDash: dataset.borderDash,
+			lineDashOffset: dataset.borderDashOffset,
+			lineJoin: dataset.borderJoinStyle,
+			lineWidth: dataset.borderWidth,
+			strokeStyle: dataset.borderColor,
+			pointStyle: dataset.pointStyle,
+			rough: roughHelpers.resolve(dataset, chart.options.plugins.rough),
+
+			// Below is extra data used for toggling the datasets
+			datasetIndex: i
+		};
+	}, this) : [];
+};
+
+/**
+ * Ported from Chart.js 2.7.3.
+ *
+ * Helper function to get the box width based on the usePointStyle option
+ * @param labelopts {Object} the label options on the legend
+ * @param fontSize {Number} the label font size
+ * @return {Number} width of the color box area
+ */
+function getBoxWidth(labelOpts, fontSize) {
+	return labelOpts.usePointStyle ?
+		fontSize * Math.SQRT2 :
+		labelOpts.boxWidth;
+}
+
+var RoughLegend = Chart.Legend.extend({
+
+	// Ported from Chart.js 2.7.3. Modified for rough legend.
+	// Actually draw the legend on the canvas
+	draw: function() {
+		var me = this;
+		var opts = me.options;
+		var labelOpts = opts.labels;
+		var globalDefault = defaults$1.global;
+		var lineDefault = globalDefault.elements.line;
+		var legendWidth = me.width;
+		var lineWidths = me.lineWidths;
+		var canvas = rough.canvas(this.chart.canvas);
+
+		if (opts.display) {
+			var ctx = me.ctx;
+			var fontColor = valueOrDefault$1(labelOpts.fontColor, globalDefault.defaultFontColor);
+			var fontSize = valueOrDefault$1(labelOpts.fontSize, globalDefault.defaultFontSize);
+			var fontStyle = valueOrDefault$1(labelOpts.fontStyle, globalDefault.defaultFontStyle);
+			var fontFamily = valueOrDefault$1(labelOpts.fontFamily, globalDefault.defaultFontFamily);
+			var labelFont = helpers$7.fontString(fontSize, fontStyle, fontFamily);
+			var cursor;
+
+			// Canvas setup
+			ctx.textAlign = 'left';
+			ctx.textBaseline = 'middle';
+			ctx.lineWidth = 0.5;
+			ctx.strokeStyle = fontColor; // for strikethrough effect
+			ctx.fillStyle = fontColor; // render in correct colour
+			ctx.font = labelFont;
+
+			var boxWidth = getBoxWidth(labelOpts, fontSize);
+			var hitboxes = me.legendHitBoxes;
+
+			// current position
+			var drawLegendBox = function(x, y, legendItem) {
+				if (isNaN(boxWidth) || boxWidth <= 0) {
+					return;
+				}
+
+				var isLineWidthZero = (valueOrDefault$1(legendItem.lineWidth, lineDefault.borderWidth) === 0);
+
+				var roughOpts = helpers$7.merge({
+					borderColor: valueOrDefault$1(legendItem.strokeStyle, globalDefault.defaultColor),
+					borderWidth: valueOrDefault$1(legendItem.lineWidth, lineDefault.borderWidth),
+					backgroundColor: valueOrDefault$1(legendItem.fillStyle, globalDefault.defaultColor)
+				}, legendItem.rough);
+
+				if (opts.labels && opts.labels.usePointStyle) {
+					// Recalculate x and y for drawPoint() because its expecting
+					// x and y to be center of figure (instead of top left)
+					var radius = fontSize * Math.SQRT2 / 2;
+					var offSet = radius / Math.SQRT2;
+					var centerX = x + offSet;
+					var centerY = y + offSet;
+
+					// Draw pointStyle as legend symbol
+					roughHelpers.drawPoint(ctx, legendItem.pointStyle, radius, centerX, centerY, 0, canvas, roughOpts);
+				} else {
+					// Draw box as legend symbol
+					canvas.rectangle(x, y, boxWidth, fontSize, roughHelpers.getFillOptions(roughOpts));
+					if (!isLineWidthZero) {
+						canvas.rectangle(x, y, boxWidth, fontSize, roughHelpers.getStrokeOptions(roughOpts));
+					}
+				}
+
+				// ctx.restore();
+			};
+			var fillText = function(x, y, legendItem, textWidth) {
+				var halfFontSize = fontSize / 2;
+				var xLeft = boxWidth + halfFontSize + x;
+				var yMiddle = y + halfFontSize;
+
+				ctx.fillText(legendItem.text, xLeft, yMiddle);
+
+				if (legendItem.hidden) {
+					// Strikethrough the text if hidden
+					ctx.beginPath();
+					ctx.lineWidth = 2;
+					ctx.moveTo(xLeft, yMiddle);
+					ctx.lineTo(xLeft + textWidth, yMiddle);
+					ctx.stroke();
+				}
+			};
+
+			// Horizontal
+			var isHorizontal = me.isHorizontal();
+			if (isHorizontal) {
+				cursor = {
+					x: me.left + ((legendWidth - lineWidths[0]) / 2),
+					y: me.top + labelOpts.padding,
+					line: 0
+				};
+			} else {
+				cursor = {
+					x: me.left + labelOpts.padding,
+					y: me.top + labelOpts.padding,
+					line: 0
+				};
+			}
+
+			var itemHeight = fontSize + labelOpts.padding;
+			helpers$7.each(me.legendItems, function(legendItem, i) {
+				var textWidth = ctx.measureText(legendItem.text).width;
+				var width = boxWidth + (fontSize / 2) + textWidth;
+				var x = cursor.x;
+				var y = cursor.y;
+
+				if (isHorizontal) {
+					if (x + width >= legendWidth) {
+						y = cursor.y += itemHeight;
+						cursor.line++;
+						x = cursor.x = me.left + ((legendWidth - lineWidths[cursor.line]) / 2);
+					}
+				} else if (y + itemHeight > me.bottom) {
+					x = cursor.x = x + me.columnWidths[cursor.line] + labelOpts.padding;
+					y = cursor.y = me.top + labelOpts.padding;
+					cursor.line++;
+				}
+
+				drawLegendBox(x, y, legendItem);
+
+				hitboxes[i].left = x;
+				hitboxes[i].top = y;
+
+				// Fill the actual label
+				fillText(x, y, legendItem, textWidth);
+
+				if (isHorizontal) {
+					cursor.x += width + (labelOpts.padding);
+				} else {
+					cursor.y += itemHeight;
+				}
+
+			});
+		}
+	}
+});
+
+// Ported from Chart.js 2.7.3. Modified for rough legend.
+function createNewLegendAndAttach(chart, legendOpts) {
+	var legend = new RoughLegend({
+		ctx: chart.ctx,
+		options: legendOpts,
+		chart: chart
+	});
+
+	layouts.configure(chart, legend, legendOpts);
+	layouts.addBox(chart, legend);
+	chart.legend = legend;
+}
+
+var RoughLegendPlugin = {
+	id: 'legend',
+
+	_element: RoughLegend,
+
+	// Ported from Chart.js 2.7.3.
+	beforeInit: function(chart) {
+		var legendOpts = chart.options.legend;
+
+		if (legendOpts) {
+			createNewLegendAndAttach(chart, legendOpts);
+		}
+	},
+
+	// Ported from Chart.js 2.7.3.
+	beforeUpdate: function(chart) {
+		var legendOpts = chart.options.legend;
+		var legend = chart.legend;
+
+		if (legendOpts) {
+			helpers$7.mergeIf(legendOpts, defaults$1.global.legend);
+
+			if (legend) {
+				layouts.configure(chart, legend, legendOpts);
+				legend.options = legendOpts;
+			} else {
+				createNewLegendAndAttach(chart, legendOpts);
+			}
+		} else if (legend) {
+			layouts.removeBox(chart, legend);
+			delete chart.legend;
+		}
+	},
+
+	// Ported from Chart.js 2.7.3.
+	afterEvent: function(chart, e) {
+		var legend = chart.legend;
+		if (legend) {
+			legend.handleEvent(e);
+		}
+	}
+};
+
+'use strict';
+
+var controllers = Chart.controllers;
+var plugins = Chart.plugins;
+
+Chart.defaults.global.plugins.rough = {
+	roughness: 1,
+	bowing: 1,
+	fillStyle: 'hachure',
+	fillWeight: 0.5,
+	hachureAngle: -41,
+	hachureGap: 4,
+	curveStepCount: 9,
+	simplification: 0
+};
+
+var roughControllers = {
+	bar: RoughBarController,
+	bubble: RoughBubbleController,
+	doughnut: RoughDoughnutController,
+	horizontalBar: RoughHorizontalBarController,
+	line: RoughLineController,
+	polarArea: RoughPolarAreaController,
+	pie: RoughDoughnutController,
+	radar: RoughRadarController,
+	scatter: RoughLineController
+};
+
+var descriptors = plugins.descriptors;
+
+plugins.descriptors = function(chart) {
+	var rough$$1 = chart._rough;
+
+	// Replace filler/legend plugins with rough filler/legend plugins
+	if (rough$$1) {
+		// chart._plugins for Chart.js 2.7.1 backward compatibility
+		var cache = chart.$plugins || chart._plugins || (chart.$plugins = chart._plugins = {});
+		if (cache.id === this._cacheId) {
+			return cache.descriptors;
+		}
+
+		var p = this._plugins;
+		var result;
+
+		this._plugins = p.map(function(plugin) {
+			if (plugin.id === 'filler') {
+				return RoughFillerPlugin;
+			} else if (plugin.id === 'legend') {
+				return RoughLegendPlugin;
+			}
+			return plugin;
+		});
+	}
+
+	result = descriptors.apply(this, arguments);
+
+	if (rough$$1) {
+		this._plugins = p;
+	}
+
+	return result;
+};
+
+var RoughPlugin$1 = {
+	id: 'rough',
+
+	beforeInit: function(chart) {
+		chart._rough = {};
+
+		chart.buildOrUpdateControllers = function() {
+			var result;
+
+			// Replace controllers with rough controllers on creation
+			Chart.controllers = roughControllers;
+			result = Chart.prototype.buildOrUpdateControllers.apply(this, arguments);
+			Chart.controllers = controllers;
+
+			return result;
+		};
+
+		// Remove the existing legend if exists
+		if (chart.legend) {
+			Chart.layouts.removeBox(chart, chart.legend);
+			delete chart.legend;
+		}
+
+		// Invalidate plugin cache and create new one
+		delete chart.$plugins;
+		// For Chart.js 2.7.1 backward compatibility
+		delete chart._plugins;
+		plugins.descriptors(chart);
+	}
+};
+
+'use strict';
+
+Chart.helpers.rough = roughHelpers;
+
+Chart.elements.RoughArc = RoughArc;
+Chart.elements.RoughLine = RoughLine;
+Chart.elements.RoughPoint = RoughPoint;
+Chart.elements.RoughRectangle = RoughRectangle;
+
+Chart.controllers.roughBar = RoughBarController;
+Chart.controllers.roughBubble = RoughBubbleController;
+Chart.controllers.roughDoughnut = Chart.controllers.roughPie = RoughDoughnutController;
+Chart.controllers.roughHorizontalBar = RoughHorizontalBarController;
+Chart.controllers.roughLine = Chart.controllers.roughScatter = RoughLineController;
+Chart.controllers.roughPolarArea = RoughPolarAreaController;
+Chart.controllers.roughRadar = RoughRadarController;
+
+return RoughPlugin$1;
+
+})));
diff --git a/dist/chartjs-plugin-rough.min.js b/dist/chartjs-plugin-rough.min.js
new file mode 100644
index 0000000..b38d1ac
--- /dev/null
+++ b/dist/chartjs-plugin-rough.min.js
@@ -0,0 +1,11 @@
+/*
+ * @license
+ * chartjs-plugin-rough
+ * https://github.com/nagix/chartjs-plugin-rough/
+ * Version: 0.1.0
+ *
+ * Copyright 2019 Akihiko Kusanagi
+ * Released under the MIT license
+ * https://github.com/nagix/chartjs-plugin-rough/blob/master/LICENSE.md
+ */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t(require("chart.js"),require("roughjs")):"function"==typeof define&&define.amd?define(["chart.js","roughjs"],t):e.ChartRough=t(e.Chart,e.rough)}(this,function(g,D){"use strict";g=g&&g.hasOwnProperty("default")?g.default:g,D=D&&D.hasOwnProperty("default")?D.default:D;var e=g.helpers;g.layouts=g.layouts||g.layoutService,e.canvas=e.canvas||{},e.canvas._isPointInArea=e.canvas._isPointInArea||function(e,t){return e.x>t.left-1e-6&&e.x<t.right+1e-6&&e.y>t.top-1e-6&&e.y<t.bottom+1e-6};var t=Math.PI,C=t/180,S=t/4,_=2*t/3,W={roughKeys:["roughness","bowing","fillStyle","fillWeight","hachureAngle","hachureGap","curveStepCount","simplification"],drawPoint:function(e,t,o,r,a,n,l,i){var d,s,u,h,c,g,p,b,f,v,m=this.getFillOptions(i),y=this.getStrokeOptions(i),x=(n||0)*C;if(!t||"object"!=typeof t||"[object HTMLImageElement]"!==(d=t.toString())&&"[object HTMLCanvasElement]"!==d){if(!(isNaN(o)||o<=0))switch(t){default:l.circle(r,a,2*o,m),l.circle(r,a,2*o,y);break;case"triangle":(b=[]).push([r+Math.sin(x)*o,a-Math.cos(x)*o]),x+=_,b.push([r+Math.sin(x)*o,a-Math.cos(x)*o]),x+=_,b.push([r+Math.sin(x)*o,a-Math.cos(x)*o]),l.polygon(b,m),l.polygon(b,y);break;case"rectRounded":p=.516*o,h=Math.cos(x)*p,c=Math.sin(x)*p,x+=S,g=o-p,f="M"+(r-(s=Math.cos(x)*g)-h)+" "+(a-(u=Math.sin(x)*g)-c)+(v="A"+p+" "+p+" 0 0 1 ")+(r-s+c)+" "+(a-u-h)+"L"+(r+u+c)+" "+(a-s-h)+v+(r+u+h)+" "+(a-s+c)+"L"+(r+s+h)+" "+(a+u+c)+v+(r+s-c)+" "+(a+u+h)+"L"+(r-u-c)+" "+(a+s+h)+v+(r-u-h)+" "+(a+s-c)+"Z",l.path(f,m),l.path(f,y);break;case"rect":if(!n){g=Math.SQRT1_2*o,l.rectangle(r-g,a-g,2*g,2*g,m),l.rectangle(r-g,a-g,2*g,2*g,y);break}x+=S;case"rectRot":b=[[r-(s=Math.cos(x)*o),a-(u=Math.sin(x)*o)],[r+u,a-s],[r+s,a+u],[r-u,a+s]],l.polygon(b,m),l.polygon(b,y);break;case"crossRot":x+=S;case"cross":s=Math.cos(x)*o,u=Math.sin(x)*o,l.line(r-s,a-u,r+s,a+u,y),l.line(r+u,a-s,r-u,a+s,y);break;case"star":s=Math.cos(x)*o,u=Math.sin(x)*o,l.line(r-s,a-u,r+s,a+u,y),l.line(r+u,a-s,r-u,a+s,y),x+=S,s=Math.cos(x)*o,u=Math.sin(x)*o,l.line(r-s,a-u,r+s,a+u,y),l.line(r+u,a-s,r-u,a+s,y);break;case"line":s=Math.cos(x)*o,u=Math.sin(x)*o,l.line(r-s,a-u,r+s,a+u,y);break;case"dash":l.line(r,a,r+Math.cos(x)*o,a+Math.sin(x)*o,y)}}else e.drawImage(t,r-t.width/2,a-t.height/2,t.width,t.height)},lineTo:function(e,t,o){var r,a=t.steppedLine;return a?("middle"===a?"L"+(r=(e.x+t.x)/2)+" "+(o?t.y:e.y)+"L"+r+" "+(o?e.y:t.y):"after"===a&&!o||"after"!==a&&o?"L"+e.x+" "+t.y:"L"+t.x+" "+e.y)+"L"+t.x+" "+t.y:t.tension?"C "+(o?e.controlPointPreviousX:e.controlPointNextX)+" "+(o?e.controlPointPreviousY:e.controlPointNextY)+","+(o?t.controlPointNextX:t.controlPointPreviousX)+" "+(o?t.controlPointNextY:t.controlPointPreviousY)+","+t.x+" "+t.y:"L"+t.x+" "+t.y},resolve:function(e,t){var o=e.rough;return!1===o?null:(!0===o&&(o={}),g.helpers.merge({},[t,o]))},getFillOptions:function(t){var o={stroke:"transparent",fill:t.backgroundColor};return this.roughKeys.forEach(function(e){void 0!==t[e]&&(o[e]=t[e])}),o},getStrokeOptions:function(t){var o={stroke:t.borderColor,strokeWidth:t.borderWidth};return["roughness","bowing","curveStepCount","simplification"].forEach(function(e){void 0!==t[e]&&(o[e]=t[e])}),o}},o=g.elements.Arc.extend({draw:function(){var e=this._view,t=e.x,o=e.y,r=e.outerRadius,a=e.innerRadius,n=e.startAngle,l=e.endAngle,i=Math.cos(n),d=Math.sin(n),s=Math.cos(l),u=Math.sin(l),h=l-n>Math.PI?1:0,c=D.canvas(this._chart.canvas),g="M"+(t+r*i)+" "+(o+r*d)+"A"+r+" "+r+" 0 "+h+" 1 "+(t+r*s)+" "+(o+r*u)+"L"+(t+a*s)+" "+(o+a*u)+"A"+a+" "+a+" 0 "+h+" 0 "+(t+a*i)+" "+(o+a*d)+"Z";c.path(g,W.getFillOptions(e)),e.borderWidth&&c.path(g,W.getStrokeOptions(e))}}),r=g.elements.Line.extend({draw:function(){var e,t,o,r,a=this._view,n=a.spanGaps,l=this._children.slice(),i=-1,d=D.canvas(this._chart.canvas),s="";for(this._loop&&l.length&&l.push(l[0]),i=-1,e=0;e<l.length;++e)t=l[e],o=g.helpers.previousItem(l,e),r=t._view,0===e?r.skip||(s+="M"+r.x+" "+r.y,i=e):(o=-1===i?o:l[i],r.skip||(s+=i!==e-1&&!n||-1===i?"M"+r.x+" "+r.y:W.lineTo(o._view,t._view),i=e));d.path(s,W.getStrokeOptions(a))}}),a=g.elements.Point.extend({draw:function(e){var t=this._view,o=this._chart,r=o.ctx,a=D.canvas(o.canvas);t.skip||(void 0===e||g.helpers.canvas._isPointInArea(t,e))&&W.drawPoint(r,t.pointStyle,t.radius,t.x,t.y,t.rotation,a,t)}}),n=g.elements.Rectangle.extend({draw:function(){var e,t,o,r,a,n,l,i=this._view,d=i.borderWidth,s=D.canvas(this._chart.canvas);if(l=i.horizontal?(e=i.base,t=i.x,o=i.y-i.height/2,r=i.y+i.height/2,a=e<t?1:-1,n=1,i.borderSkipped||"left"):(e=i.x-i.width/2,t=i.x+i.width/2,a=1,n=(o=i.y)<(r=i.base)?1:-1,i.borderSkipped||"bottom"),d){var u=Math.min(Math.abs(e-t),Math.abs(o-r)),h=(d=u<d?u:d)/2,c=e+("left"!==l?h*a:0),g=t+("right"!==l?-h*a:0),p=o+("top"!==l?h*n:0),b=r+("bottom"!==l?-h*n:0);c!==g&&(o=p,r=b),p!==b&&(e=c,t=g)}var f=[[e,r],[e,o],[t,o],[t,r]],v=["bottom","left","top","right"].indexOf(l,0);function m(e){return f[(v+e)%4]}if(-1===v&&(v=0),s.rectangle(f[1][0],f[1][1],f[3][0]-f[1][0],f[3][1]-f[1][1],W.getFillOptions(i)),d)for(var y=m(0),x=1;x<4;x++){var C=m(x);s.line(y[0],y[1],C[0],C[1],W.getStrokeOptions(i)),y=C}}}),u=g.helpers,h=u.options.resolve,l=g.controllers.bar.extend({dataElementType:n,updateElement:function(e,t,o){var r=this,a=r.chart,n=r.getMeta(),l=r.getDataset(),i=e.custom||{},d=a.options,s=d.elements.rectangle;e._xScale=r.getScaleForId(n.xAxisID),e._yScale=r.getScaleForId(n.yAxisID),e._datasetIndex=r.index,e._index=t,e._model=u.merge({datasetLabel:l.label,label:a.data.labels[t],borderSkipped:u.valueOrDefault(i.borderSkipped,s.borderSkipped),backgroundColor:h([i.backgroundColor,l.backgroundColor,s.backgroundColor],void 0,t),borderColor:h([i.borderColor,l.borderColor,s.borderColor],void 0,t),borderWidth:h([i.borderWidth,l.borderWidth,s.borderWidth],void 0,t)},W.resolve(l,d.plugins.rough)),r.updateElementGeometry(e,t,o),e.pivot()}}),i=g.controllers.bubble.extend({dataElementType:a,updateElement:function(e,t,o){var r=this,a=r.getMeta(),n=e.custom||{},l=r.getScaleForId(a.xAxisID),i=r.getScaleForId(a.yAxisID),d=r._resolveElementOptions(e,t),s=r.getDataset().data[t],u=r.index,h=o?l.getPixelForDecimal(.5):l.getPixelForValue("object"==typeof s?s:NaN,t,u),c=o?i.getBasePixel():i.getPixelForValue(s,t,u);e._xScale=l,e._yScale=i,e._options=d,e._datasetIndex=u,e._index=t,e._model=g.helpers.merge({backgroundColor:d.backgroundColor,borderColor:d.borderColor,borderWidth:d.borderWidth,hitRadius:d.hitRadius,pointStyle:d.pointStyle,rotation:d.rotation,radius:o?0:d.radius,skip:n.skip||isNaN(h)||isNaN(c),x:h,y:c},W.resolve(r.getDataset(),r.chart.options.plugins.rough)),e.pivot()}}),d=g.defaults,y=g.helpers,x=y.options.resolve;d.doughnut.legend.labels.generateLabels=d.pie.legend.labels.generateLabels=function(d){var s=d.data;return s.labels.length&&s.datasets.length?s.labels.map(function(e,t){var o=d.getDatasetMeta(0),r=s.datasets[0],a=o.data[t],n=a&&a.custom||{},l=d.options,i=l.elements.arc;return{text:e,fillStyle:x([n.backgroundColor,r.backgroundColor,i.backgroundColor],void 0,t),strokeStyle:x([n.borderColor,r.borderColor,i.borderColor],void 0,t),lineWidth:x([n.borderWidth,r.borderWidth,i.borderWidth],void 0,t),hidden:isNaN(r.data[t])||o.data[t].hidden,rough:W.resolve(r,l.plugins.rough),index:t}}):[]};var s=g.controllers.doughnut.extend({dataElementType:o,updateElement:function(e,t,o){var r=this,a=r.chart,n=a.chartArea,l=a.options,i=l.animation,d=(n.left+n.right)/2,s=(n.top+n.bottom)/2,u=l.rotation,h=l.rotation,c=r.getDataset(),g=o&&i.animateRotate?0:e.hidden?0:r.calculateCircumference(c.data[t])*(l.circumference/(2*Math.PI)),p=o&&i.animateScale?0:r.innerRadius,b=o&&i.animateScale?0:r.outerRadius;y.extend(e,{_datasetIndex:r.index,_index:t,_model:{x:d+a.offsetX,y:s+a.offsetY,startAngle:u,endAngle:h,circumference:g,outerRadius:b,innerRadius:p,label:y.valueAtIndexOrDefault(c.label,t,a.data.labels[t])}});var f=e._model,v=e.custom||{},m=l.elements.arc;f.backgroundColor=x([v.backgroundColor,c.backgroundColor,m.backgroundColor],void 0,t),f.borderColor=x([v.borderColor,c.borderColor,m.borderColor],void 0,t),f.borderWidth=x([v.borderWidth,c.borderWidth,m.borderWidth],void 0,t),y.merge(f,W.resolve(c,l.plugins.rough)),o&&i.animateRotate||(f.startAngle=0===t?l.rotation:r.getMeta().data[t-1]._model.endAngle,f.endAngle=f.startAngle+f.circumference),e.pivot()}}),c=l.extend({getValueScaleId:function(){return this.getMeta().xAxisID},getIndexScaleId:function(){return this.getMeta().yAxisID}}),p=g.helpers,b=p.valueOrDefault,f=p.options.resolve,v=g.controllers.line;var m=v.extend({datasetElementType:r,dataElementType:a,update:function(e){var t,o,r,a,n=this,l=n.getMeta(),i=l.dataset,d=l.data||[],s=n.chart.options,u=s.elements.line,h=n.getScaleForId(l.yAxisID),c=n.getDataset(),g=(a=s,b(c.showLine,a.showLines));for(g&&(r=i.custom||{},void 0!==c.tension&&void 0===c.lineTension&&(c.lineTension=c.tension),i._scale=h,i._datasetIndex=n.index,i._children=d,i._model=p.merge({spanGaps:b(c.spanGaps,s.spanGaps),tension:f([r.tension,c.lineTension,u.tension]),backgroundColor:f([r.backgroundColor,c.backgroundColor,u.backgroundColor]),borderWidth:f([r.borderWidth,c.borderWidth,u.borderWidth]),borderColor:f([r.borderColor,c.borderColor,u.borderColor]),borderCapStyle:f([r.borderCapStyle,c.borderCapStyle,u.borderCapStyle]),borderDash:f([r.borderDash,c.borderDash,u.borderDash]),borderDashOffset:f([r.borderDashOffset,c.borderDashOffset,u.borderDashOffset]),borderJoinStyle:f([r.borderJoinStyle,c.borderJoinStyle,u.borderJoinStyle]),fill:f([r.fill,c.fill,u.fill]),steppedLine:f([r.steppedLine,c.steppedLine,u.stepped]),cubicInterpolationMode:f([r.cubicInterpolationMode,c.cubicInterpolationMode,u.cubicInterpolationMode])},W.resolve(c,s.plugins.rough)),i.pivot()),t=0,o=d.length;t<o;++t)n.updateElement(d[t],t,e);for(g&&0!==i._model.tension&&n.updateBezierControlPoints(),t=0,o=d.length;t<o;++t)d[t].pivot()},updateElement:function(e){v.prototype.updateElement.apply(this,arguments),p.merge(e._model,W.resolve(this.getDataset(),this.chart.options.plugins.rough))}}),k=g.helpers,M=k.options.resolve;g.defaults.polarArea.legend.labels.generateLabels=function(i){var d=i.data;return d.labels.length&&d.datasets.length?d.labels.map(function(e,t){var o=i.getDatasetMeta(0),r=d.datasets[0],a=o.data[t].custom||{},n=i.options,l=n.elements.arc;return{text:e,fillStyle:M([a.backgroundColor,r.backgroundColor,l.backgroundColor],void 0,t),strokeStyle:M([a.borderColor,r.borderColor,l.borderColor],void 0,t),lineWidth:M([a.borderWidth,r.borderWidth,l.borderWidth],void 0,t),hidden:isNaN(r.data[t])||o.data[t].hidden,rough:W.resolve(r,n.plugins.rough),index:t}}):[]};var I=g.controllers.polarArea.extend({dataElementType:o,updateElement:function(e,t,o){var r,a,n=this,l=n.chart,i=n.getDataset(),d=l.options,s=d.animation,u=l.scale,h=l.data.labels,c=u.xCenter,g=u.yCenter,p=d.startAngle,b=e.hidden?0:u.getDistanceFromCenterForValue(i.data[t]);if(n.calculateCircumference){for(var f=n.calculateCircumference(i.data[t]),v=0,m=n.getMeta(),y=0;y<t;++y)isNaN(i.data[y])||m.data[y].hidden||++v;a=(r=p+f*v)+(e.hidden?0:f)}else a=(r=n._starts[t])+(e.hidden?0:n._angles[t]);var x=s.animateScale?0:u.getDistanceFromCenterForValue(i.data[t]);k.extend(e,{_datasetIndex:n.index,_index:t,_scale:u,_model:{x:c,y:g,innerRadius:0,outerRadius:o?x:b,startAngle:o&&s.animateRotate?p:r,endAngle:o&&s.animateRotate?p:a,label:k.valueAtIndexOrDefault(h,t,h[t])}});var C=d.elements.arc,S=e.custom||{},_=e._model;_.backgroundColor=M([S.backgroundColor,i.backgroundColor,C.backgroundColor],void 0,t),_.borderColor=M([S.borderColor,i.borderColor,C.borderColor],void 0,t),_.borderWidth=M([S.borderWidth,i.borderWidth,C.borderWidth],void 0,t),k.merge(_,W.resolve(i,d.plugins.rough)),e.pivot()}}),A=g.helpers,P=A.options.resolve,w=g.controllers.radar,O=w.extend({datasetElementType:r,dataElementType:a,update:function(o){var r=this,e=r.getMeta(),t=e.dataset,a=e.data,n=t.custom||{},l=r.getDataset(),i=r.chart.options,d=i.elements.line,s=r.chart.scale;void 0!==l.tension&&void 0===l.lineTension&&(l.lineTension=l.tension),A.extend(e.dataset,{_datasetIndex:r.index,_scale:s,_children:a,_loop:!0,_model:A.merge({tension:P([n.tension,l.lineTension,d.tension]),backgroundColor:P([n.backgroundColor,l.backgroundColor,d.backgroundColor]),borderWidth:P([n.borderWidth,l.borderWidth,d.borderWidth]),borderColor:P([n.borderColor,l.borderColor,d.borderColor]),fill:P([n.fill,l.fill,d.fill]),borderCapStyle:P([n.borderCapStyle,l.borderCapStyle,d.borderCapStyle]),borderDash:P([n.borderDash,l.borderDash,d.borderDash]),borderDashOffset:P([n.borderDashOffset,l.borderDashOffset,d.borderDashOffset]),borderJoinStyle:P([n.borderJoinStyle,l.borderJoinStyle,d.borderJoinStyle])},W.resolve(l,i.plugins.rough))}),e.dataset.pivot(),A.each(a,function(e,t){r.updateElement(e,t,o)},r),r.updateBezierControlPoints()},updateElement:function(e){w.prototype.updateElement.apply(this,arguments),A.merge(e._model,W.resolve(this.getDataset(),this.chart.options.plugins.rough))}}),R=g.helpers,L=g.plugins.getAll().filter(function(e){return"filler"===e.id})[0];function T(e){return e&&!e.skip}function E(e,t,o,r){var a,n;if(o&&r){for(a="M"+e[0].x+" "+e[0].y,n=1;n<o;++n)a+=W.lineTo(e[n-1],e[n]);for(a+="L"+t[r-1].x+" "+t[r-1].y,n=r-1;0<n;--n)a+=W.lineTo(t[n],t[n-1],!0);return a}}var F=R.merge({},[L,{beforeDatasetDraw:function(e,t){var o=t.meta.$filler;if(o){var r=e.ctx,a=o.el,n=a._view,l=a._children||[],i=o.mapper,d=n.backgroundColor||g.defaults.global.defaultColor;i&&d&&l.length&&(R.canvas.clipArea(r,e.chartArea),function(e,t,o,r,a,n){var l,i,d,s,u,h,c,g=t.length,p=r.spanGaps,b=[],f=[],v=0,m=0,y=D.canvas(e.canvas),x="";for(l=0,i=g+!!n;l<i;++l)u=o(s=t[d=l%g]._view,d,r),h=T(s),c=T(u),h&&c?(v=b.push(s),m=f.push(u)):v&&m&&(p?(h&&b.push(s),c&&f.push(u)):(x+=E(b,f,v,m),v=m=0,b=[],f=[]));x+=E(b,f,v,m),y.path(x,W.getFillOptions(r))}(e,l,i,n,0,a._loop),R.canvas.unclipArea(r))}}}]),N=g.defaults,B=g.helpers,J=g.layouts,j=B.isArray,z=B.valueOrDefault;N.global.legend.labels.generateLabels=function(o){var e=o.data;return j(e.datasets)?e.datasets.map(function(e,t){return{text:e.label,fillStyle:B.valueAtIndexOrDefault(e.backgroundColor,0),hidden:!o.isDatasetVisible(t),lineCap:e.borderCapStyle,lineDash:e.borderDash,lineDashOffset:e.borderDashOffset,lineJoin:e.borderJoinStyle,lineWidth:e.borderWidth,strokeStyle:e.borderColor,pointStyle:e.pointStyle,rough:W.resolve(e,o.options.plugins.rough),datasetIndex:t}},this):[]};var G=g.Legend.extend({draw:function(){var e,t,h=this,c=h.options,g=c.labels,p=N.global,b=p.elements.line,f=h.width,v=h.lineWidths,m=D.canvas(this.chart.canvas);if(c.display){var y,x=h.ctx,o=z(g.fontColor,p.defaultFontColor),C=z(g.fontSize,p.defaultFontSize),r=z(g.fontStyle,p.defaultFontStyle),a=z(g.fontFamily,p.defaultFontFamily),n=B.fontString(C,r,a);x.textAlign="left",x.textBaseline="middle",x.lineWidth=.5,x.strokeStyle=o,x.fillStyle=o,x.font=n;var S=(t=C,(e=g).usePointStyle?t*Math.SQRT2:e.boxWidth),_=h.legendHitBoxes,k=h.isHorizontal();y=k?{x:h.left+(f-v[0])/2,y:h.top+g.padding,line:0}:{x:h.left+g.padding,y:h.top+g.padding,line:0};var M=C+g.padding;B.each(h.legendItems,function(e,t){var o,r,a,n,l,i=x.measureText(e.text).width,d=S+C/2+i,s=y.x,u=y.y;k?f<=s+d&&(u=y.y+=M,y.line++,s=y.x=h.left+(f-v[y.line])/2):u+M>h.bottom&&(s=y.x=s+h.columnWidths[y.line]+g.padding,u=y.y=h.top+g.padding,y.line++),function(e,t,o){if(!(isNaN(S)||S<=0)){var r=0===z(o.lineWidth,b.borderWidth),a=B.merge({borderColor:z(o.strokeStyle,p.defaultColor),borderWidth:z(o.lineWidth,b.borderWidth),backgroundColor:z(o.fillStyle,p.defaultColor)},o.rough);if(c.labels&&c.labels.usePointStyle){var n=C*Math.SQRT2/2,l=n/Math.SQRT2,i=e+l,d=t+l;W.drawPoint(x,o.pointStyle,n,i,d,0,m,a)}else m.rectangle(e,t,S,C,W.getFillOptions(a)),r||m.rectangle(e,t,S,C,W.getStrokeOptions(a))}}(s,u,e),_[t].left=s,_[t].top=u,o=e,r=i,n=S+(a=C/2)+s,l=u+a,x.fillText(o.text,n,l),o.hidden&&(x.beginPath(),x.lineWidth=2,x.moveTo(n,l),x.lineTo(n+r,l),x.stroke()),k?y.x+=d+g.padding:y.y+=M})}}});function V(e,t){var o=new G({ctx:e.ctx,options:t,chart:e});J.configure(e,o,t),J.addBox(e,o),e.legend=o}var H={id:"legend",_element:G,beforeInit:function(e){var t=e.options.legend;t&&V(e,t)},beforeUpdate:function(e){var t=e.options.legend,o=e.legend;t?(B.mergeIf(t,N.global.legend),o?(J.configure(e,o,t),o.options=t):V(e,t)):o&&(J.removeBox(e,o),delete e.legend)},afterEvent:function(e,t){var o=e.legend;o&&o.handleEvent(t)}},X=g.controllers,Y=g.plugins;g.defaults.global.plugins.rough={roughness:1,bowing:1,fillStyle:"hachure",fillWeight:.5,hachureAngle:-41,hachureGap:4,curveStepCount:9,simplification:0};var Q={bar:l,bubble:i,doughnut:s,horizontalBar:c,line:m,polarArea:I,pie:s,radar:O,scatter:m},$=Y.descriptors;Y.descriptors=function(e){var t=e._rough;if(t){var o=e.$plugins||e._plugins||(e.$plugins=e._plugins={});if(o.id===this._cacheId)return o.descriptors;var r,a=this._plugins;this._plugins=a.map(function(e){return"filler"===e.id?F:"legend"===e.id?H:e})}return r=$.apply(this,arguments),t&&(this._plugins=a),r};var U={id:"rough",beforeInit:function(e){e._rough={},e.buildOrUpdateControllers=function(){var e;return g.controllers=Q,e=g.prototype.buildOrUpdateControllers.apply(this,arguments),g.controllers=X,e},e.legend&&(g.layouts.removeBox(e,e.legend),delete e.legend),delete e.$plugins,delete e._plugins,Y.descriptors(e)}};return g.helpers.rough=W,g.elements.RoughArc=o,g.elements.RoughLine=r,g.elements.RoughPoint=a,g.elements.RoughRectangle=n,g.controllers.roughBar=l,g.controllers.roughBubble=i,g.controllers.roughDoughnut=g.controllers.roughPie=s,g.controllers.roughHorizontalBar=c,g.controllers.roughLine=g.controllers.roughScatter=m,g.controllers.roughPolarArea=I,g.controllers.roughRadar=O,U});
\ No newline at end of file