From 9dc344274b77f7b7cba486df02bc773773cdf2b9 Mon Sep 17 00:00:00 2001
From: Evgeniy <eeiaao@gmail.com>
Date: Sun, 6 Jan 2019 16:02:32 +0300
Subject: [PATCH 1/6] core.scaleService: more accurate module dependency
 management

---
 src/core/core.scaleService.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/core.scaleService.js b/src/core/core.scaleService.js
index fe945382003..5e9be1070a0 100644
--- a/src/core/core.scaleService.js
+++ b/src/core/core.scaleService.js
@@ -1,7 +1,7 @@
 'use strict';
 
 var defaults = require('./core.defaults');
-var helpers = require('../helpers/index');
+var helpers = require('../helpers/helpers.core');
 var layouts = require('./core.layouts');
 
 module.exports = {

From 10bd94e0f2aebf31879e89adf06dec97fdcaba59 Mon Sep 17 00:00:00 2001
From: Evgeniy <eeiaao@gmail.com>
Date: Sun, 6 Jan 2019 16:09:09 +0300
Subject: [PATCH 2/6] core.layout: more accurate module dependency management

---
 src/core/core.layouts.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/core.layouts.js b/src/core/core.layouts.js
index b99612bbebd..44ef9025c1d 100644
--- a/src/core/core.layouts.js
+++ b/src/core/core.layouts.js
@@ -1,6 +1,6 @@
 'use strict';
 
-var helpers = require('../helpers/index');
+var helpers = require('../helpers/helpers.core');
 
 function filterByPosition(array, position) {
 	return helpers.where(array, function(v) {

From c96409629016890bfb10aaf393354cf03f3a9b55 Mon Sep 17 00:00:00 2001
From: Evgeniy <eeiaao@gmail.com>
Date: Sun, 6 Jan 2019 14:55:35 +0300
Subject: [PATCH 3/6] Dispatch canvas related helpers to helpers.canvas

---
 samples/advanced/data-labelling.html     |   4 +-
 samples/charts/bar/horizontal.html       |   2 +-
 samples/charts/bar/vertical.html         |   2 +-
 samples/charts/bubble.html               |   2 +-
 samples/charts/polar-area.html           |   2 +-
 samples/charts/radar-skip-points.html    |   2 +-
 samples/charts/radar.html                |   2 +-
 samples/charts/scatter/basic.html        |   2 +-
 samples/charts/scatter/multi-axis.html   |   2 +-
 samples/legend/point-style.html          |   2 +-
 samples/legend/positioning.html          |   2 +-
 samples/scales/logarithmic/scatter.html  |   2 +-
 samples/scales/time/combo.html           |   2 +-
 samples/scales/time/financial.html       |   2 +-
 samples/scales/time/line-point-data.html |   2 +-
 samples/scales/time/line.html            |   2 +-
 samples/tooltips/custom-points.html      |   2 +-
 src/controllers/controller.bubble.js     |   4 +-
 src/controllers/controller.line.js       |   4 +-
 src/controllers/controller.radar.js      |   4 +-
 src/core/core.animations.js              |   2 +-
 src/core/core.datasetController.js       |   2 +-
 src/core/core.helpers.js                 | 103 --------------------
 src/core/core.scale.js                   |   8 +-
 src/core/core.tooltip.js                 |  12 +--
 src/helpers/helpers.canvas.js            | 108 +++++++++++++++++++++
 src/platforms/platform.dom.js            |   2 +-
 src/scales/scale.radialLinear.js         |   2 +-
 test/specs/controller.bar.tests.js       |  12 +--
 test/specs/core.helpers.tests.js         | 112 ----------------------
 test/specs/helpers.canvas.tests.js       | 116 +++++++++++++++++++++++
 31 files changed, 268 insertions(+), 259 deletions(-)

diff --git a/samples/advanced/data-labelling.html b/samples/advanced/data-labelling.html
index 52eb07b8fd3..5c4dfaf811d 100644
--- a/samples/advanced/data-labelling.html
+++ b/samples/advanced/data-labelling.html
@@ -21,7 +21,7 @@
 	</div>
 	<button id="randomizeData">Randomize Data</button>
 	<script>
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var barChartData = {
 			labels: ['January', 'February', 'March', 'April', 'May', 'June', 'July'],
 			datasets: [{
@@ -84,7 +84,7 @@
 							var fontSize = 16;
 							var fontStyle = 'normal';
 							var fontFamily = 'Helvetica Neue';
-							ctx.font = Chart.helpers.fontString(fontSize, fontStyle, fontFamily);
+							ctx.font = Chart.helpers.canvas.fontString(fontSize, fontStyle, fontFamily);
 
 							// Just naively convert to string for now
 							var dataString = dataset.data[index].toString();
diff --git a/samples/charts/bar/horizontal.html b/samples/charts/bar/horizontal.html
index e174ad2ca35..ebe623d92d1 100644
--- a/samples/charts/bar/horizontal.html
+++ b/samples/charts/bar/horizontal.html
@@ -25,7 +25,7 @@
 	<button id="removeData">Remove Data</button>
 	<script>
 		var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var horizontalBarChartData = {
 			labels: ['January', 'February', 'March', 'April', 'May', 'June', 'July'],
 			datasets: [{
diff --git a/samples/charts/bar/vertical.html b/samples/charts/bar/vertical.html
index 5127d4937c2..f1e08594f97 100644
--- a/samples/charts/bar/vertical.html
+++ b/samples/charts/bar/vertical.html
@@ -25,7 +25,7 @@
 	<button id="removeData">Remove Data</button>
 	<script>
 		var MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var barChartData = {
 			labels: ['January', 'February', 'March', 'April', 'May', 'June', 'July'],
 			datasets: [{
diff --git a/samples/charts/bubble.html b/samples/charts/bubble.html
index 092c1fb464b..d5a0c166c21 100644
--- a/samples/charts/bubble.html
+++ b/samples/charts/bubble.html
@@ -27,7 +27,7 @@
 		var DEFAULT_DATASET_SIZE = 7;
 
 		var addedCount = 0;
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var bubbleChartData = {
 			animation: {
 				duration: 10000
diff --git a/samples/charts/polar-area.html b/samples/charts/polar-area.html
index 1c40a645181..8e9d3eebfba 100644
--- a/samples/charts/polar-area.html
+++ b/samples/charts/polar-area.html
@@ -27,7 +27,7 @@
 		};
 
 		var chartColors = window.chartColors;
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var config = {
 			data: {
 				datasets: [{
diff --git a/samples/charts/radar-skip-points.html b/samples/charts/radar-skip-points.html
index ab042e2dcd6..e2ebb6cb011 100644
--- a/samples/charts/radar-skip-points.html
+++ b/samples/charts/radar-skip-points.html
@@ -24,7 +24,7 @@
 			return Math.round(Math.random() * 100);
 		};
 
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var config = {
 			type: 'radar',
 			data: {
diff --git a/samples/charts/radar.html b/samples/charts/radar.html
index 7eda09a7fb4..b09cd6d5ed2 100644
--- a/samples/charts/radar.html
+++ b/samples/charts/radar.html
@@ -28,7 +28,7 @@
 			return Math.round(Math.random() * 100);
 		};
 
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var config = {
 			type: 'radar',
 			data: {
diff --git a/samples/charts/scatter/basic.html b/samples/charts/scatter/basic.html
index 63b8efafbdd..669779609b6 100644
--- a/samples/charts/scatter/basic.html
+++ b/samples/charts/scatter/basic.html
@@ -20,7 +20,7 @@
 	</div>
 	<button id="randomizeData">Randomize Data</button>
 	<script>
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		function generateData() {
 			var data = [];
 			for (var i = 0; i < 7; i++) {
diff --git a/samples/charts/scatter/multi-axis.html b/samples/charts/scatter/multi-axis.html
index 6c20b98f0de..9d5120daca4 100644
--- a/samples/charts/scatter/multi-axis.html
+++ b/samples/charts/scatter/multi-axis.html
@@ -20,7 +20,7 @@
 	</div>
 	<button id="randomizeData">Randomize Data</button>
 	<script>
-	var color = Chart.helpers.color;
+	var color = Chart.helpers.canvas.color;
 	var scatterChartData = {
 		datasets: [{
 			label: 'My First dataset',
diff --git a/samples/legend/point-style.html b/samples/legend/point-style.html
index b7acea4bd84..7ee051f0e92 100644
--- a/samples/legend/point-style.html
+++ b/samples/legend/point-style.html
@@ -35,7 +35,7 @@
 		</div>
 	</div>
 	<script>
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		function createConfig(colorName) {
 			return {
 				type: 'line',
diff --git a/samples/legend/positioning.html b/samples/legend/positioning.html
index 5bd2259cfb1..3b35d1ecb26 100644
--- a/samples/legend/positioning.html
+++ b/samples/legend/positioning.html
@@ -41,7 +41,7 @@
 		</div>
 	</div>
 	<script>
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		function createConfig(legendPosition, colorName) {
 			return {
 				type: 'line',
diff --git a/samples/scales/logarithmic/scatter.html b/samples/scales/logarithmic/scatter.html
index 5f266a5cda1..c48c8388dce 100644
--- a/samples/scales/logarithmic/scatter.html
+++ b/samples/scales/logarithmic/scatter.html
@@ -19,7 +19,7 @@
 		<canvas id="canvas"></canvas>
 	</div>
 	<script>
-	var color = Chart.helpers.color;
+	var color = Chart.helpers.canvas.color;
 	var scatterChartData = {
 		datasets: [{
 			borderColor: window.chartColors.red,
diff --git a/samples/scales/time/combo.html b/samples/scales/time/combo.html
index d435e74c69c..dd5dbd5dfea 100644
--- a/samples/scales/time/combo.html
+++ b/samples/scales/time/combo.html
@@ -33,7 +33,7 @@
 			return moment().add(days, 'd').format(timeFormat);
 		}
 
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var config = {
 			type: 'bar',
 			data: {
diff --git a/samples/scales/time/financial.html b/samples/scales/time/financial.html
index b261b898661..947d8606443 100644
--- a/samples/scales/time/financial.html
+++ b/samples/scales/time/financial.html
@@ -57,7 +57,7 @@
 		ctx.canvas.width = 1000;
 		ctx.canvas.height = 300;
 
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var cfg = {
 			type: 'bar',
 			data: {
diff --git a/samples/scales/time/line-point-data.html b/samples/scales/time/line-point-data.html
index 604a49b4f1a..f633b851f6e 100644
--- a/samples/scales/time/line-point-data.html
+++ b/samples/scales/time/line-point-data.html
@@ -33,7 +33,7 @@
 			return moment().add(days, 'd').format();
 		}
 
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var config = {
 			type: 'line',
 			data: {
diff --git a/samples/scales/time/line.html b/samples/scales/time/line.html
index 77c81b7aa1b..4cf21fb7605 100644
--- a/samples/scales/time/line.html
+++ b/samples/scales/time/line.html
@@ -37,7 +37,7 @@
 			return moment().add(days, 'd').format(timeFormat);
 		}
 
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var config = {
 			type: 'line',
 			data: {
diff --git a/samples/tooltips/custom-points.html b/samples/tooltips/custom-points.html
index f779f62f9c7..20ff6340d9c 100644
--- a/samples/tooltips/custom-points.html
+++ b/samples/tooltips/custom-points.html
@@ -69,7 +69,7 @@
 				});
 			}
 		};
-		var color = Chart.helpers.color;
+		var color = Chart.helpers.canvas.color;
 		var lineChartData = {
 			labels: ['January', 'February', 'March', 'April', 'May', 'June', 'July'],
 			datasets: [{
diff --git a/src/controllers/controller.bubble.js b/src/controllers/controller.bubble.js
index 77956c9dc7b..f59bb843582 100644
--- a/src/controllers/controller.bubble.js
+++ b/src/controllers/controller.bubble.js
@@ -109,8 +109,8 @@ module.exports = DatasetController.extend({
 			radius: model.radius
 		};
 
-		model.backgroundColor = helpers.valueOrDefault(options.hoverBackgroundColor, helpers.getHoverColor(options.backgroundColor));
-		model.borderColor = helpers.valueOrDefault(options.hoverBorderColor, helpers.getHoverColor(options.borderColor));
+		model.backgroundColor = helpers.valueOrDefault(options.hoverBackgroundColor, helpers.canvas.getHoverColor(options.backgroundColor));
+		model.borderColor = helpers.valueOrDefault(options.hoverBorderColor, helpers.canvas.getHoverColor(options.borderColor));
 		model.borderWidth = helpers.valueOrDefault(options.hoverBorderWidth, options.borderWidth);
 		model.radius = options.radius + options.hoverRadius;
 	},
diff --git a/src/controllers/controller.line.js b/src/controllers/controller.line.js
index 03f7faf96d2..be8cde2a92a 100644
--- a/src/controllers/controller.line.js
+++ b/src/controllers/controller.line.js
@@ -344,8 +344,8 @@ module.exports = DatasetController.extend({
 			radius: model.radius
 		};
 
-		model.backgroundColor = custom.hoverBackgroundColor || helpers.valueAtIndexOrDefault(dataset.pointHoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor));
-		model.borderColor = custom.hoverBorderColor || helpers.valueAtIndexOrDefault(dataset.pointHoverBorderColor, index, helpers.getHoverColor(model.borderColor));
+		model.backgroundColor = custom.hoverBackgroundColor || helpers.valueAtIndexOrDefault(dataset.pointHoverBackgroundColor, index, helpers.canvas.getHoverColor(model.backgroundColor));
+		model.borderColor = custom.hoverBorderColor || helpers.valueAtIndexOrDefault(dataset.pointHoverBorderColor, index, helpers.canvas.getHoverColor(model.borderColor));
 		model.borderWidth = custom.hoverBorderWidth || helpers.valueAtIndexOrDefault(dataset.pointHoverBorderWidth, index, model.borderWidth);
 		model.radius = custom.hoverRadius || helpers.valueAtIndexOrDefault(dataset.pointHoverRadius, index, this.chart.options.elements.point.hoverRadius);
 	}
diff --git a/src/controllers/controller.radar.js b/src/controllers/controller.radar.js
index 4d69928d87b..a2cc5c593a1 100644
--- a/src/controllers/controller.radar.js
+++ b/src/controllers/controller.radar.js
@@ -165,8 +165,8 @@ module.exports = DatasetController.extend({
 		};
 
 		model.radius = custom.hoverRadius ? custom.hoverRadius : helpers.valueAtIndexOrDefault(dataset.pointHoverRadius, index, this.chart.options.elements.point.hoverRadius);
-		model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : helpers.valueAtIndexOrDefault(dataset.pointHoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor));
-		model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : helpers.valueAtIndexOrDefault(dataset.pointHoverBorderColor, index, helpers.getHoverColor(model.borderColor));
+		model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : helpers.valueAtIndexOrDefault(dataset.pointHoverBackgroundColor, index, helpers.canvas.getHoverColor(model.backgroundColor));
+		model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : helpers.valueAtIndexOrDefault(dataset.pointHoverBorderColor, index, helpers.canvas.getHoverColor(model.borderColor));
 		model.borderWidth = custom.hoverBorderWidth ? custom.hoverBorderWidth : helpers.valueAtIndexOrDefault(dataset.pointHoverBorderWidth, index, model.borderWidth);
 	}
 });
diff --git a/src/core/core.animations.js b/src/core/core.animations.js
index c307f499562..cec26496fc4 100644
--- a/src/core/core.animations.js
+++ b/src/core/core.animations.js
@@ -67,7 +67,7 @@ module.exports = {
 			// Skip animation frame requests until the active one is executed.
 			// This can happen when processing mouse events, e.g. 'mousemove'
 			// and 'mouseout' events will trigger multiple renders.
-			me.request = helpers.requestAnimFrame.call(window, function() {
+			me.request = helpers.canvas.requestAnimFrame.call(window, function() {
 				me.request = null;
 				me.startDigest();
 			});
diff --git a/src/core/core.datasetController.js b/src/core/core.datasetController.js
index 3b47dffdcb3..c56362fb0bb 100644
--- a/src/core/core.datasetController.js
+++ b/src/core/core.datasetController.js
@@ -246,7 +246,7 @@ helpers.extend(DatasetController.prototype, {
 		var index = element._index;
 		var custom = element.custom || {};
 		var valueOrDefault = helpers.valueAtIndexOrDefault;
-		var getHoverColor = helpers.getHoverColor;
+		var getHoverColor = helpers.canvas.getHoverColor;
 		var model = element._model;
 
 		element.$previousStyle = {
diff --git a/src/core/core.helpers.js b/src/core/core.helpers.js
index 82f2c9811b7..01e1c33d747 100644
--- a/src/core/core.helpers.js
+++ b/src/core/core.helpers.js
@@ -2,8 +2,6 @@
 /* global document: false */
 'use strict';
 
-var color = require('chartjs-color');
-var defaults = require('./core.defaults');
 var helpers = require('../helpers/index');
 var scaleService = require('../core/core.scaleService');
 
@@ -405,22 +403,6 @@ module.exports = function() {
 
 		return niceFraction * Math.pow(10, exponent);
 	};
-	// Request animation polyfill - https://www.paulirish.com/2011/requestanimationframe-for-smart-animating/
-	helpers.requestAnimFrame = (function() {
-		if (typeof window === 'undefined') {
-			return function(callback) {
-				callback();
-			};
-		}
-		return window.requestAnimationFrame ||
-			window.webkitRequestAnimationFrame ||
-			window.mozRequestAnimationFrame ||
-			window.oRequestAnimationFrame ||
-			window.msRequestAnimationFrame ||
-			function(callback) {
-				return window.setTimeout(callback, 1000 / 60);
-			};
-	}());
 	// -- DOM methods
 	helpers.getRelativePosition = function(evt, chart) {
 		var mouseX, mouseY;
@@ -588,89 +570,4 @@ module.exports = function() {
 			canvas.style.width = width + 'px';
 		}
 	};
-	// -- Canvas methods
-	helpers.fontString = function(pixelSize, fontStyle, fontFamily) {
-		return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;
-	};
-	helpers.longestText = function(ctx, font, arrayOfThings, cache) {
-		cache = cache || {};
-		var data = cache.data = cache.data || {};
-		var gc = cache.garbageCollect = cache.garbageCollect || [];
-
-		if (cache.font !== font) {
-			data = cache.data = {};
-			gc = cache.garbageCollect = [];
-			cache.font = font;
-		}
-
-		ctx.font = font;
-		var longest = 0;
-		helpers.each(arrayOfThings, function(thing) {
-			// Undefined strings and arrays should not be measured
-			if (thing !== undefined && thing !== null && helpers.isArray(thing) !== true) {
-				longest = helpers.measureText(ctx, data, gc, longest, thing);
-			} else if (helpers.isArray(thing)) {
-				// if it is an array lets measure each element
-				// to do maybe simplify this function a bit so we can do this more recursively?
-				helpers.each(thing, function(nestedThing) {
-					// Undefined strings and arrays should not be measured
-					if (nestedThing !== undefined && nestedThing !== null && !helpers.isArray(nestedThing)) {
-						longest = helpers.measureText(ctx, data, gc, longest, nestedThing);
-					}
-				});
-			}
-		});
-
-		var gcLen = gc.length / 2;
-		if (gcLen > arrayOfThings.length) {
-			for (var i = 0; i < gcLen; i++) {
-				delete data[gc[i]];
-			}
-			gc.splice(0, gcLen);
-		}
-		return longest;
-	};
-	helpers.measureText = function(ctx, data, gc, longest, string) {
-		var textWidth = data[string];
-		if (!textWidth) {
-			textWidth = data[string] = ctx.measureText(string).width;
-			gc.push(string);
-		}
-		if (textWidth > longest) {
-			longest = textWidth;
-		}
-		return longest;
-	};
-	helpers.numberOfLabelLines = function(arrayOfThings) {
-		var numberOfLines = 1;
-		helpers.each(arrayOfThings, function(thing) {
-			if (helpers.isArray(thing)) {
-				if (thing.length > numberOfLines) {
-					numberOfLines = thing.length;
-				}
-			}
-		});
-		return numberOfLines;
-	};
-
-	helpers.color = !color ?
-		function(value) {
-			console.error('Color.js not found!');
-			return value;
-		} :
-		function(value) {
-			/* global CanvasGradient */
-			if (value instanceof CanvasGradient) {
-				value = defaults.global.defaultColor;
-			}
-
-			return color(value);
-		};
-
-	helpers.getHoverColor = function(colorValue) {
-		/* global CanvasPattern */
-		return (colorValue instanceof CanvasPattern || colorValue instanceof CanvasGradient) ?
-			colorValue :
-			helpers.color(colorValue).saturate(0.5).darken(0.1).rgbString();
-	};
 };
diff --git a/src/core/core.scale.js b/src/core/core.scale.js
index 690491fbc60..5a2df626326 100644
--- a/src/core/core.scale.js
+++ b/src/core/core.scale.js
@@ -92,7 +92,7 @@ function getPixelForGridLine(scale, index, offsetGridLines) {
 
 function computeTextSize(context, tick, font) {
 	return helpers.isArray(tick) ?
-		helpers.longestText(context, font, tick) :
+		helpers.canvas.longestText(context, font, tick) :
 		context.measureText(tick).width;
 }
 
@@ -323,7 +323,7 @@ module.exports = Element.extend({
 		var labelRotation = tickOpts.minRotation || 0;
 
 		if (labels.length && me.options.display && me.isHorizontal()) {
-			var originalLabelWidth = helpers.longestText(context, tickFont.string, labels, me.longestTextCache);
+			var originalLabelWidth = helpers.canvas.longestText(context, tickFont.font, labels, me.longestTextCache);
 			var labelWidth = originalLabelWidth;
 			var cosRotation, sinRotation;
 
@@ -410,8 +410,8 @@ module.exports = Element.extend({
 
 		// Don't bother fitting the ticks if we are not showing them
 		if (tickOpts.display && display) {
-			var largestTextWidth = helpers.longestText(me.ctx, tickFont.string, labels, me.longestTextCache);
-			var tallestLabelHeightInLines = helpers.numberOfLabelLines(labels);
+			var largestTextWidth = helpers.canvas.longestText(me.ctx, tickFont.font, labels, me.longestTextCache);
+			var tallestLabelHeightInLines = helpers.canvas.numberOfLabelLines(labels);
 			var lineSpace = tickFont.size * 0.5;
 			var tickPadding = me.options.ticks.padding;
 
diff --git a/src/core/core.tooltip.js b/src/core/core.tooltip.js
index fb081e60b31..340d7c90868 100644
--- a/src/core/core.tooltip.js
+++ b/src/core/core.tooltip.js
@@ -305,11 +305,11 @@ function getTooltipSize(tooltip, model) {
 		width = Math.max(width, ctx.measureText(line).width + widthPadding);
 	};
 
-	ctx.font = helpers.fontString(titleFontSize, model._titleFontStyle, model._titleFontFamily);
+	ctx.font = helpers.canvas.fontString(titleFontSize, model._titleFontStyle, model._titleFontFamily);
 	helpers.each(model.title, maxLineWidth);
 
 	// Body width
-	ctx.font = helpers.fontString(bodyFontSize, model._bodyFontStyle, model._bodyFontFamily);
+	ctx.font = helpers.canvas.fontString(bodyFontSize, model._bodyFontStyle, model._bodyFontFamily);
 	helpers.each(model.beforeBody.concat(model.afterBody), maxLineWidth);
 
 	// Body lines may include some extra width due to the color box
@@ -324,7 +324,7 @@ function getTooltipSize(tooltip, model) {
 	widthPadding = 0;
 
 	// Footer width
-	ctx.font = helpers.fontString(footerFontSize, model._footerFontStyle, model._footerFontFamily);
+	ctx.font = helpers.canvas.fontString(footerFontSize, model._footerFontStyle, model._footerFontFamily);
 	helpers.each(model.footer, maxLineWidth);
 
 	// Add padding
@@ -737,7 +737,7 @@ var exports = Element.extend({
 			var titleSpacing = vm.titleSpacing;
 
 			ctx.fillStyle = vm.titleFontColor;
-			ctx.font = helpers.fontString(titleFontSize, vm._titleFontStyle, vm._titleFontFamily);
+			ctx.font = helpers.canvas.fontString(titleFontSize, vm._titleFontStyle, vm._titleFontFamily);
 
 			var i, len;
 			for (i = 0, len = title.length; i < len; ++i) {
@@ -758,7 +758,7 @@ var exports = Element.extend({
 
 		ctx.textAlign = vm._bodyAlign;
 		ctx.textBaseline = 'top';
-		ctx.font = helpers.fontString(bodyFontSize, vm._bodyFontStyle, vm._bodyFontFamily);
+		ctx.font = helpers.canvas.fontString(bodyFontSize, vm._bodyFontStyle, vm._bodyFontFamily);
 
 		// Before Body
 		var xLinePadding = 0;
@@ -822,7 +822,7 @@ var exports = Element.extend({
 			ctx.textBaseline = 'top';
 
 			ctx.fillStyle = vm.footerFontColor;
-			ctx.font = helpers.fontString(vm.footerFontSize, vm._footerFontStyle, vm._footerFontFamily);
+			ctx.font = helpers.canvas.fontString(vm.footerFontSize, vm._footerFontStyle, vm._footerFontFamily);
 
 			helpers.each(footer, function(line) {
 				ctx.fillText(line, pt.x, pt.y);
diff --git a/src/helpers/helpers.canvas.js b/src/helpers/helpers.canvas.js
index 1513386a8cb..a0bd2e611d4 100644
--- a/src/helpers/helpers.canvas.js
+++ b/src/helpers/helpers.canvas.js
@@ -1,5 +1,7 @@
 'use strict';
 
+var color = require('chartjs-color');
+var defaults = require('../core/core.defaults');
 var helpers = require('./helpers.core');
 
 var PI = Math.PI;
@@ -225,6 +227,112 @@ var exports = {
 			flip ? target.controlPointNextY : target.controlPointPreviousY,
 			target.x,
 			target.y);
+	},
+
+	// ### TODO Obviously it's not a Canvas' deal. Put method somewhere else.
+	// Request animation polyfill - http://www.paulirish.com/2011/requestanimationframe-for-smart-animating/
+	requestAnimFrame: (function() {
+		if (typeof window === 'undefined') {
+			return function(callback) {
+				callback();
+			};
+		}
+		return window.requestAnimationFrame ||
+			window.webkitRequestAnimationFrame ||
+			window.mozRequestAnimationFrame ||
+			window.oRequestAnimationFrame ||
+			window.msRequestAnimationFrame ||
+			function(callback) {
+				return window.setTimeout(callback, 1000 / 60);
+			};
+	}()),
+
+	fontString: function(pixelSize, fontStyle, fontFamily) {
+		return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;
+	},
+
+	longestText: function(ctx, font, arrayOfThings, cache) {
+		cache = cache || {};
+		var data = cache.data = cache.data || {};
+		var gc = cache.garbageCollect = cache.garbageCollect || [];
+
+		if (cache.font !== font) {
+			data = cache.data = {};
+			gc = cache.garbageCollect = [];
+			cache.font = font;
+		}
+
+		ctx.font = font;
+		var longest = 0;
+		helpers.each(arrayOfThings, function(thing) {
+			// Undefined strings and arrays should not be measured
+			if (thing !== undefined && thing !== null && helpers.isArray(thing) !== true) {
+				longest = exports.measureText(ctx, data, gc, longest, thing);
+			} else if (helpers.isArray(thing)) {
+				// if it is an array lets measure each element
+				// to do maybe simplify this function a bit so we can do this more recursively?
+				helpers.each(thing, function(nestedThing) {
+					// Undefined strings and arrays should not be measured
+					if (nestedThing !== undefined && nestedThing !== null && !helpers.isArray(nestedThing)) {
+						longest = exports.measureText(ctx, data, gc, longest, nestedThing);
+					}
+				});
+			}
+		});
+
+		var gcLen = gc.length / 2;
+		if (gcLen > arrayOfThings.length) {
+			for (var i = 0; i < gcLen; i++) {
+				delete data[gc[i]];
+			}
+			gc.splice(0, gcLen);
+		}
+		return longest;
+	},
+
+	measureText: function(ctx, data, gc, longest, string) {
+		var textWidth = data[string];
+		if (!textWidth) {
+			textWidth = data[string] = ctx.measureText(string).width;
+			gc.push(string);
+		}
+		if (textWidth > longest) {
+			longest = textWidth;
+		}
+		return longest;
+	},
+
+	numberOfLabelLines: function(arrayOfThings) {
+		var numberOfLines = 1;
+		helpers.each(arrayOfThings, function(thing) {
+			if (helpers.isArray(thing)) {
+				if (thing.length > numberOfLines) {
+					numberOfLines = thing.length;
+				}
+			}
+		});
+		return numberOfLines;
+	},
+
+	color: !color ?
+		function(value) {
+			console.error('Color.js not found!');
+			return value;
+		} :
+		function(value) {
+			/* global CanvasGradient */
+			if (value instanceof CanvasGradient) {
+				value = defaults.defaultColor;
+			}
+
+			return color(value);
+		},
+
+	getHoverColor: function(colorValue) {
+		/* global CanvasPattern */
+		return (colorValue instanceof CanvasPattern || colorValue instanceof CanvasGradient) ?
+			colorValue :
+			exports.color(colorValue).saturate(0.5).darken(0.1).rgbString();
 	}
 };
 
diff --git a/src/platforms/platform.dom.js b/src/platforms/platform.dom.js
index c70d73963aa..f0cfbff4170 100644
--- a/src/platforms/platform.dom.js
+++ b/src/platforms/platform.dom.js
@@ -158,7 +158,7 @@ function throttled(fn, thisArg) {
 
 		if (!ticking) {
 			ticking = true;
-			helpers.requestAnimFrame.call(window, function() {
+			helpers.canvas.requestAnimFrame.call(window, function() {
 				ticking = false;
 				fn.apply(thisArg, args);
 			});
diff --git a/src/scales/scale.radialLinear.js b/src/scales/scale.radialLinear.js
index a407ee0295c..703c9911ba9 100644
--- a/src/scales/scale.radialLinear.js
+++ b/src/scales/scale.radialLinear.js
@@ -72,7 +72,7 @@ function getTickBackdropHeight(opts) {
 function measureLabelSize(ctx, lineHeight, label) {
 	if (helpers.isArray(label)) {
 		return {
-			w: helpers.longestText(ctx, ctx.font, label),
+			w: helpers.canvas.longestText(ctx, ctx.font, label),
 			h: label.length * lineHeight
 		};
 	}
diff --git a/test/specs/controller.bar.tests.js b/test/specs/controller.bar.tests.js
index 4b33c939c61..e53af653356 100644
--- a/test/specs/controller.bar.tests.js
+++ b/test/specs/controller.bar.tests.js
@@ -1450,8 +1450,8 @@ describe('Chart.controllers.bar', function() {
 		expect(bar._model.borderColor).toBe('rgb(15, 15, 15)');
 		expect(bar._model.borderWidth).toBe(3.14);
 		meta.controller.setHoverStyle(bar);
-		expect(bar._model.backgroundColor).toBe(helpers.getHoverColor('rgb(128, 128, 128)'));
-		expect(bar._model.borderColor).toBe(helpers.getHoverColor('rgb(15, 15, 15)'));
+		expect(bar._model.backgroundColor).toBe(helpers.canvas.getHoverColor('rgb(128, 128, 128)'));
+		expect(bar._model.borderColor).toBe(helpers.canvas.getHoverColor('rgb(15, 15, 15)'));
 		expect(bar._model.borderWidth).toBe(3.14);
 		meta.controller.removeHoverStyle(bar);
 		expect(bar._model.backgroundColor).toBe('rgb(128, 128, 128)');
@@ -1468,8 +1468,8 @@ describe('Chart.controllers.bar', function() {
 		expect(bar._model.borderColor).toBe('rgb(9, 9, 9)');
 		expect(bar._model.borderWidth).toBe(2.5);
 		meta.controller.setHoverStyle(bar);
-		expect(bar._model.backgroundColor).toBe(helpers.getHoverColor('rgb(255, 255, 255)'));
-		expect(bar._model.borderColor).toBe(helpers.getHoverColor('rgb(9, 9, 9)'));
+		expect(bar._model.backgroundColor).toBe(helpers.canvas.getHoverColor('rgb(255, 255, 255)'));
+		expect(bar._model.borderColor).toBe(helpers.canvas.getHoverColor('rgb(9, 9, 9)'));
 		expect(bar._model.borderWidth).toBe(2.5);
 		meta.controller.removeHoverStyle(bar);
 		expect(bar._model.backgroundColor).toBe('rgb(255, 255, 255)');
@@ -1488,8 +1488,8 @@ describe('Chart.controllers.bar', function() {
 		expect(bar._model.borderColor).toBe('rgb(0, 255, 0)');
 		expect(bar._model.borderWidth).toBe(1.5);
 		meta.controller.setHoverStyle(bar);
-		expect(bar._model.backgroundColor).toBe(helpers.getHoverColor('rgb(255, 0, 0)'));
-		expect(bar._model.borderColor).toBe(helpers.getHoverColor('rgb(0, 255, 0)'));
+		expect(bar._model.backgroundColor).toBe(helpers.canvas.getHoverColor('rgb(255, 0, 0)'));
+		expect(bar._model.borderColor).toBe(helpers.canvas.getHoverColor('rgb(0, 255, 0)'));
 		expect(bar._model.borderWidth).toBe(1.5);
 		meta.controller.removeHoverStyle(bar);
 		expect(bar._model.backgroundColor).toBe('rgb(255, 0, 0)');
diff --git a/test/specs/core.helpers.tests.js b/test/specs/core.helpers.tests.js
index 796148aaf6c..43104b07dbd 100644
--- a/test/specs/core.helpers.tests.js
+++ b/test/specs/core.helpers.tests.js
@@ -499,68 +499,6 @@ describe('Core helper tests', function() {
 		expect(helpers.previousItem(testData, 1, true)).toEqual(0);
 	});
 
-	it('should return the width of the longest text in an Array and 2D Array', function() {
-		var context = window.createMockContext();
-		var font = "normal 12px 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif";
-		var arrayOfThings1D = ['FooBar', 'Bar'];
-		var arrayOfThings2D = [['FooBar_1', 'Bar_2'], 'Foo_1'];
-
-
-		// Regardless 'FooBar' is the longest label it should return (characters * 10)
-		expect(helpers.longestText(context, font, arrayOfThings1D, {})).toEqual(60);
-		expect(helpers.longestText(context, font, arrayOfThings2D, {})).toEqual(80);
-		// We check to make sure we made the right calls to the canvas.
-		expect(context.getCalls()).toEqual([{
-			name: 'measureText',
-			args: ['FooBar']
-		}, {
-			name: 'measureText',
-			args: ['Bar']
-		}, {
-			name: 'measureText',
-			args: ['FooBar_1']
-		}, {
-			name: 'measureText',
-			args: ['Bar_2']
-		}, {
-			name: 'measureText',
-			args: ['Foo_1']
-		}]);
-	});
-
-	it('compare text with current longest and update', function() {
-		var context = window.createMockContext();
-		var data = {};
-		var gc = [];
-		var longest = 70;
-
-		expect(helpers.measureText(context, data, gc, longest, 'foobar')).toEqual(70);
-		expect(helpers.measureText(context, data, gc, longest, 'foobar_')).toEqual(70);
-		expect(helpers.measureText(context, data, gc, longest, 'foobar_1')).toEqual(80);
-		// We check to make sure we made the right calls to the canvas.
-		expect(context.getCalls()).toEqual([{
-			name: 'measureText',
-			args: ['foobar']
-		}, {
-			name: 'measureText',
-			args: ['foobar_']
-		}, {
-			name: 'measureText',
-			args: ['foobar_1']
-		}]);
-	});
-
-	it('count look at all the labels and return maximum number of lines', function() {
-		window.createMockContext();
-		var arrayOfThings1 = ['Foo', 'Bar'];
-		var arrayOfThings2 = [['Foo', 'Bar'], 'Foo'];
-		var arrayOfThings3 = [['Foo', 'Bar', 'Boo'], ['Foo', 'Bar'], 'Foo'];
-
-		expect(helpers.numberOfLabelLines(arrayOfThings1)).toEqual(1);
-		expect(helpers.numberOfLabelLines(arrayOfThings2)).toEqual(2);
-		expect(helpers.numberOfLabelLines(arrayOfThings3)).toEqual(3);
-	});
-
 	it ('should get the maximum width and height for a node', function() {
 		// Create div with fixed size as a test bed
 		var div = document.createElement('div');
@@ -811,54 +749,4 @@ describe('Core helper tests', function() {
 
 		document.body.removeChild(div);
 	});
-
-	describe('Color helper', function() {
-		function isColorInstance(obj) {
-			return typeof obj === 'object' && obj.hasOwnProperty('values') && obj.values.hasOwnProperty('rgb');
-		}
-
-		it('should return a color when called with a color', function() {
-			expect(isColorInstance(helpers.color('rgb(1, 2, 3)'))).toBe(true);
-		});
-
-		it('should return a color when called with a CanvasGradient instance', function() {
-			var context = document.createElement('canvas').getContext('2d');
-			var gradient = context.createLinearGradient(0, 1, 2, 3);
-
-			expect(isColorInstance(helpers.color(gradient))).toBe(true);
-		});
-	});
-
-	describe('Background hover color helper', function() {
-		it('should return a CanvasPattern when called with a CanvasPattern', function(done) {
-			var dots = new Image();
-			dots.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAMAAAAolt3jAAAAD1BMVEUAAAD///////////////+PQt5oAAAABXRSTlMAHlFhZsfk/BEAAAAqSURBVHgBY2BgZGJmYmSAAUYWEIDzmcBcJhiXGcxlRpPFrhdmMiqgvX0AcGIBEUAo6UAAAAAASUVORK5CYII=';
-			dots.onload = function() {
-				var chartContext = document.createElement('canvas').getContext('2d');
-				var patternCanvas = document.createElement('canvas');
-				var patternContext = patternCanvas.getContext('2d');
-				var pattern = patternContext.createPattern(dots, 'repeat');
-				patternContext.fillStyle = pattern;
-
-				var backgroundColor = helpers.getHoverColor(chartContext.createPattern(patternCanvas, 'repeat'));
-
-				expect(backgroundColor instanceof CanvasPattern).toBe(true);
-
-				done();
-			};
-		});
-
-		it('should return a CanvasGradient when called with a CanvasGradient', function() {
-			var context = document.createElement('canvas').getContext('2d');
-			var gradient = context.createLinearGradient(0, 1, 2, 3);
-
-			expect(helpers.getHoverColor(gradient) instanceof CanvasGradient).toBe(true);
-		});
-
-		it('should return a modified version of color when called with a color', function() {
-			var originalColorRGB = 'rgb(70, 191, 189)';
-
-			expect(helpers.getHoverColor('#46BFBD')).not.toEqual(originalColorRGB);
-		});
-	});
 });
diff --git a/test/specs/helpers.canvas.tests.js b/test/specs/helpers.canvas.tests.js
index 9654ef28e7b..1690de0035a 100644
--- a/test/specs/helpers.canvas.tests.js
+++ b/test/specs/helpers.canvas.tests.js
@@ -100,4 +100,120 @@ describe('Chart.helpers.canvas', function() {
 			expect(isPointInArea({x: 0, y: 256 + 1e-3}, area)).toBe(false);
 		});
 	});
+
+	describe('longestText', function() {
+		it('should return the width of the longest text in an Array and 2D Array', function() {
+			var context = window.createMockContext();
+			var font = "normal 12px 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif";
+			var arrayOfThings1D = ['FooBar', 'Bar'];
+			var arrayOfThings2D = [['FooBar_1', 'Bar_2'], 'Foo_1'];
+
+
+			// Regardless 'FooBar' is the longest label it should return (characters * 10)
+			expect(helpers.canvas.longestText(context, font, arrayOfThings1D, {})).toEqual(60);
+			expect(helpers.canvas.longestText(context, font, arrayOfThings2D, {})).toEqual(80);
+			// We check to make sure we made the right calls to the canvas.
+			expect(context.getCalls()).toEqual([{
+				name: 'measureText',
+				args: ['FooBar']
+			}, {
+				name: 'measureText',
+				args: ['Bar']
+			}, {
+				name: 'measureText',
+				args: ['FooBar_1']
+			}, {
+				name: 'measureText',
+				args: ['Bar_2']
+			}, {
+				name: 'measureText',
+				args: ['Foo_1']
+			}]);
+		});
+	});
+	describe('measureText', function() {
+		it('compare text with current longest and update', function() {
+			var context = window.createMockContext();
+			var data = {};
+			var gc = [];
+			var longest = 70;
+
+			expect(helpers.canvas.measureText(context, data, gc, longest, 'foobar')).toEqual(70);
+			expect(helpers.canvas.measureText(context, data, gc, longest, 'foobar_')).toEqual(70);
+			expect(helpers.canvas.measureText(context, data, gc, longest, 'foobar_1')).toEqual(80);
+			// We check to make sure we made the right calls to the canvas.
+			expect(context.getCalls()).toEqual([{
+				name: 'measureText',
+				args: ['foobar']
+			}, {
+				name: 'measureText',
+				args: ['foobar_']
+			}, {
+				name: 'measureText',
+				args: ['foobar_1']
+			}]);
+		});
+	});
+	describe('numberOfLabelLines', function() {
+		it('count look at all the labels and return maximum number of lines', function() {
+			window.createMockContext();
+			var arrayOfThings1 = ['Foo', 'Bar'];
+			var arrayOfThings2 = [['Foo', 'Bar'], 'Foo'];
+			var arrayOfThings3 = [['Foo', 'Bar', 'Boo'], ['Foo', 'Bar'], 'Foo'];
+
+			expect(helpers.canvas.numberOfLabelLines(arrayOfThings1)).toEqual(1);
+			expect(helpers.canvas.numberOfLabelLines(arrayOfThings2)).toEqual(2);
+			expect(helpers.canvas.numberOfLabelLines(arrayOfThings3)).toEqual(3);
+		});
+	});
+
+	describe('Color helper', function() {
+		function isColorInstance(obj) {
+			return typeof obj === 'object' && obj.hasOwnProperty('values') && obj.values.hasOwnProperty('rgb');
+		}
+
+		it('should return a color when called with a color', function() {
+			expect(isColorInstance(helpers.canvas.color('rgb(1, 2, 3)'))).toBe(true);
+		});
+
+		it('should return a color when called with a CanvasGradient instance', function() {
+			var context = document.createElement('canvas').getContext('2d');
+			var gradient = context.createLinearGradient(0, 1, 2, 3);
+
+			expect(isColorInstance(helpers.canvas.color(gradient))).toBe(true);
+		});
+	});
+
+	describe('Background hover color helper', function() {
+		it('should return a CanvasPattern when called with a CanvasPattern', function(done) {
+			var dots = new Image();
+			dots.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAMAAAAolt3jAAAAD1BMVEUAAAD///////////////+PQt5oAAAABXRSTlMAHlFhZsfk/BEAAAAqSURBVHgBY2BgZGJmYmSAAUYWEIDzmcBcJhiXGcxlRpPFrhdmMiqgvX0AcGIBEUAo6UAAAAAASUVORK5CYII=';
+			dots.onload = function() {
+				var chartContext = document.createElement('canvas').getContext('2d');
+				var patternCanvas = document.createElement('canvas');
+				var patternContext = patternCanvas.getContext('2d');
+				var pattern = patternContext.createPattern(dots, 'repeat');
+				patternContext.fillStyle = pattern;
+
+				var backgroundColor = helpers.canvas.getHoverColor(chartContext.createPattern(patternCanvas, 'repeat'));
+
+				expect(backgroundColor instanceof CanvasPattern).toBe(true);
+
+				done();
+			};
+		});
+
+		it('should return a CanvasGradient when called with a CanvasGradient', function() {
+			var context = document.createElement('canvas').getContext('2d');
+			var gradient = context.createLinearGradient(0, 1, 2, 3);
+
+			expect(helpers.canvas.getHoverColor(gradient) instanceof CanvasGradient).toBe(true);
+		});
+
+		it('should return a modified version of color when called with a color', function() {
+			var originalColorRGB = 'rgb(70, 191, 189)';
+
+			expect(helpers.canvas.getHoverColor('#46BFBD')).not.toEqual(originalColorRGB);
+		});
+	});
 });

From 2df5dacd515cc546a25eb99346d66422241536f6 Mon Sep 17 00:00:00 2001
From: Evgeniy <eeiaao@gmail.com>
Date: Sun, 6 Jan 2019 15:15:37 +0300
Subject: [PATCH 4/6] Dispatch math related methods to helpers.math

---
 samples/scales/logarithmic/scatter.html |   2 +-
 src/controllers/controller.line.js      |   8 +-
 src/controllers/controller.radar.js     |   6 +-
 src/core/core.element.js                |   2 +-
 src/core/core.helpers.js                | 289 ----------------------
 src/core/core.scale.js                  |  10 +-
 src/core/core.ticks.js                  |   6 +-
 src/core/core.tooltip.js                |   2 +-
 src/elements/element.arc.js             |   2 +-
 src/elements/element.line.js            |   2 +-
 src/helpers/helpers.math.js             | 281 +++++++++++++++++++++
 src/helpers/index.js                    |   1 +
 src/scales/scale.linear.js              |   4 +-
 src/scales/scale.linearbase.js          |  20 +-
 src/scales/scale.logarithmic.js         |  32 +--
 src/scales/scale.radialLinear.js        |   6 +-
 src/scales/scale.time.js                |   2 +-
 test/specs/core.helpers.tests.js        | 305 -----------------------
 test/specs/global.deprecations.tests.js |   6 +-
 test/specs/helpers.math.tests.js        | 313 ++++++++++++++++++++++++
 20 files changed, 650 insertions(+), 649 deletions(-)
 create mode 100644 src/helpers/helpers.math.js
 create mode 100644 test/specs/helpers.math.tests.js

diff --git a/samples/scales/logarithmic/scatter.html b/samples/scales/logarithmic/scatter.html
index c48c8388dce..c4519a73320 100644
--- a/samples/scales/logarithmic/scatter.html
+++ b/samples/scales/logarithmic/scatter.html
@@ -137,7 +137,7 @@
 						position: 'bottom',
 						ticks: {
 							userCallback: function(tick) {
-								var remain = tick / (Math.pow(10, Math.floor(Chart.helpers.log10(tick))));
+								var remain = tick / (Math.pow(10, Math.floor(Chart.helpers.math.log10(tick))));
 								if (remain === 1 || remain === 2 || remain === 5) {
 									return tick.toString() + 'Hz';
 								}
diff --git a/src/controllers/controller.line.js b/src/controllers/controller.line.js
index be8cde2a92a..df486d073fd 100644
--- a/src/controllers/controller.line.js
+++ b/src/controllers/controller.line.js
@@ -264,15 +264,15 @@ module.exports = DatasetController.extend({
 		}
 
 		if (lineModel.cubicInterpolationMode === 'monotone') {
-			helpers.splineCurveMonotone(points);
+			helpers.math.splineCurveMonotone(points);
 		} else {
 			for (i = 0, ilen = points.length; i < ilen; ++i) {
 				point = points[i];
 				model = point._model;
-				controlPoints = helpers.splineCurve(
-					helpers.previousItem(points, i)._model,
+				controlPoints = helpers.math.splineCurve(
+					helpers.math.previousItem(points, i)._model,
 					model,
-					helpers.nextItem(points, i)._model,
+					helpers.math.nextItem(points, i)._model,
 					lineModel.tension
 				);
 				model.controlPointPreviousX = controlPoints.previous.x;
diff --git a/src/controllers/controller.radar.js b/src/controllers/controller.radar.js
index a2cc5c593a1..fa9bcf1fd70 100644
--- a/src/controllers/controller.radar.js
+++ b/src/controllers/controller.radar.js
@@ -135,10 +135,10 @@ module.exports = DatasetController.extend({
 
 		for (i = 0, ilen = points.length; i < ilen; i++) {
 			model = points[i]._model;
-			controlPoints = helpers.splineCurve(
-				helpers.previousItem(points, i, true)._model,
+			controlPoints = helpers.math.splineCurve(
+				helpers.math.previousItem(points, i, true)._model,
 				model,
-				helpers.nextItem(points, i, true)._model,
+				helpers.math.nextItem(points, i, true)._model,
 				model.tension
 			);
 
diff --git a/src/core/core.element.js b/src/core/core.element.js
index 665f20c4302..f43205a932c 100644
--- a/src/core/core.element.js
+++ b/src/core/core.element.js
@@ -106,7 +106,7 @@ helpers.extend(Element.prototype, {
 	},
 
 	hasValue: function() {
-		return helpers.isNumber(this._model.x) && helpers.isNumber(this._model.y);
+		return helpers.math.isNumber(this._model.x) && helpers.math.isNumber(this._model.y);
 	}
 });
 
diff --git a/src/core/core.helpers.js b/src/core/core.helpers.js
index 01e1c33d747..fea57de4166 100644
--- a/src/core/core.helpers.js
+++ b/src/core/core.helpers.js
@@ -114,295 +114,6 @@ module.exports = function() {
 			}
 		}
 	};
-
-	// -- Math methods
-	helpers.isNumber = function(n) {
-		return !isNaN(parseFloat(n)) && isFinite(n);
-	};
-	helpers.almostEquals = function(x, y, epsilon) {
-		return Math.abs(x - y) < epsilon;
-	};
-	helpers.almostWhole = function(x, epsilon) {
-		var rounded = Math.round(x);
-		return (((rounded - epsilon) < x) && ((rounded + epsilon) > x));
-	};
-	helpers.max = function(array) {
-		return array.reduce(function(max, value) {
-			if (!isNaN(value)) {
-				return Math.max(max, value);
-			}
-			return max;
-		}, Number.NEGATIVE_INFINITY);
-	};
-	helpers.min = function(array) {
-		return array.reduce(function(min, value) {
-			if (!isNaN(value)) {
-				return Math.min(min, value);
-			}
-			return min;
-		}, Number.POSITIVE_INFINITY);
-	};
-	helpers.sign = Math.sign ?
-		function(x) {
-			return Math.sign(x);
-		} :
-		function(x) {
-			x = +x; // convert to a number
-			if (x === 0 || isNaN(x)) {
-				return x;
-			}
-			return x > 0 ? 1 : -1;
-		};
-	helpers.log10 = Math.log10 ?
-		function(x) {
-			return Math.log10(x);
-		} :
-		function(x) {
-			var exponent = Math.log(x) * Math.LOG10E; // Math.LOG10E = 1 / Math.LN10.
-			// Check for whole powers of 10,
-			// which due to floating point rounding error should be corrected.
-			var powerOf10 = Math.round(exponent);
-			var isPowerOf10 = x === Math.pow(10, powerOf10);
-
-			return isPowerOf10 ? powerOf10 : exponent;
-		};
-	helpers.toRadians = function(degrees) {
-		return degrees * (Math.PI / 180);
-	};
-	helpers.toDegrees = function(radians) {
-		return radians * (180 / Math.PI);
-	};
-
-	/**
-	 * Returns the number of decimal places
-	 * i.e. the number of digits after the decimal point, of the value of this Number.
-	 * @param {Number} x - A number.
-	 * @returns {Number} The number of decimal places.
-	 */
-	helpers.decimalPlaces = function(x) {
-		if (!helpers.isFinite(x)) {
-			return;
-		}
-		var e = 1;
-		var p = 0;
-		while (Math.round(x * e) / e !== x) {
-			e *= 10;
-			p++;
-		}
-		return p;
-	};
-
-	// Gets the angle from vertical upright to the point about a centre.
-	helpers.getAngleFromPoint = function(centrePoint, anglePoint) {
-		var distanceFromXCenter = anglePoint.x - centrePoint.x;
-		var distanceFromYCenter = anglePoint.y - centrePoint.y;
-		var radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
-
-		var angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
-
-		if (angle < (-0.5 * Math.PI)) {
-			angle += 2.0 * Math.PI; // make sure the returned angle is in the range of (-PI/2, 3PI/2]
-		}
-
-		return {
-			angle: angle,
-			distance: radialDistanceFromCenter
-		};
-	};
-	helpers.distanceBetweenPoints = function(pt1, pt2) {
-		return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
-	};
-
-	/**
-	 * Provided for backward compatibility, not available anymore
-	 * @function Chart.helpers.aliasPixel
-	 * @deprecated since version 2.8.0
-	 * @todo remove at version 3
-	 */
-	helpers.aliasPixel = function(pixelWidth) {
-		return (pixelWidth % 2 === 0) ? 0 : 0.5;
-	};
-
-	/**
-	 * Returns the aligned pixel value to avoid anti-aliasing blur
-	 * @param {Chart} chart - The chart instance.
-	 * @param {Number} pixel - A pixel value.
-	 * @param {Number} width - The width of the element.
-	 * @returns {Number} The aligned pixel value.
-	 * @private
-	 */
-	helpers._alignPixel = function(chart, pixel, width) {
-		var devicePixelRatio = chart.currentDevicePixelRatio;
-		var halfWidth = width / 2;
-		return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;
-	};
-
-	helpers.splineCurve = function(firstPoint, middlePoint, afterPoint, t) {
-		// Props to Rob Spencer at scaled innovation for his post on splining between points
-		// http://scaledinnovation.com/analytics/splines/aboutSplines.html
-
-		// This function must also respect "skipped" points
-
-		var previous = firstPoint.skip ? middlePoint : firstPoint;
-		var current = middlePoint;
-		var next = afterPoint.skip ? middlePoint : afterPoint;
-
-		var d01 = Math.sqrt(Math.pow(current.x - previous.x, 2) + Math.pow(current.y - previous.y, 2));
-		var d12 = Math.sqrt(Math.pow(next.x - current.x, 2) + Math.pow(next.y - current.y, 2));
-
-		var s01 = d01 / (d01 + d12);
-		var s12 = d12 / (d01 + d12);
-
-		// If all points are the same, s01 & s02 will be inf
-		s01 = isNaN(s01) ? 0 : s01;
-		s12 = isNaN(s12) ? 0 : s12;
-
-		var fa = t * s01; // scaling factor for triangle Ta
-		var fb = t * s12;
-
-		return {
-			previous: {
-				x: current.x - fa * (next.x - previous.x),
-				y: current.y - fa * (next.y - previous.y)
-			},
-			next: {
-				x: current.x + fb * (next.x - previous.x),
-				y: current.y + fb * (next.y - previous.y)
-			}
-		};
-	};
-	helpers.EPSILON = Number.EPSILON || 1e-14;
-	helpers.splineCurveMonotone = function(points) {
-		// This function calculates Bézier control points in a similar way than |splineCurve|,
-		// but preserves monotonicity of the provided data and ensures no local extremums are added
-		// between the dataset discrete points due to the interpolation.
-		// See : https://en.wikipedia.org/wiki/Monotone_cubic_interpolation
-
-		var pointsWithTangents = (points || []).map(function(point) {
-			return {
-				model: point._model,
-				deltaK: 0,
-				mK: 0
-			};
-		});
-
-		// Calculate slopes (deltaK) and initialize tangents (mK)
-		var pointsLen = pointsWithTangents.length;
-		var i, pointBefore, pointCurrent, pointAfter;
-		for (i = 0; i < pointsLen; ++i) {
-			pointCurrent = pointsWithTangents[i];
-			if (pointCurrent.model.skip) {
-				continue;
-			}
-
-			pointBefore = i > 0 ? pointsWithTangents[i - 1] : null;
-			pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null;
-			if (pointAfter && !pointAfter.model.skip) {
-				var slopeDeltaX = (pointAfter.model.x - pointCurrent.model.x);
-
-				// In the case of two points that appear at the same x pixel, slopeDeltaX is 0
-				pointCurrent.deltaK = slopeDeltaX !== 0 ? (pointAfter.model.y - pointCurrent.model.y) / slopeDeltaX : 0;
-			}
-
-			if (!pointBefore || pointBefore.model.skip) {
-				pointCurrent.mK = pointCurrent.deltaK;
-			} else if (!pointAfter || pointAfter.model.skip) {
-				pointCurrent.mK = pointBefore.deltaK;
-			} else if (this.sign(pointBefore.deltaK) !== this.sign(pointCurrent.deltaK)) {
-				pointCurrent.mK = 0;
-			} else {
-				pointCurrent.mK = (pointBefore.deltaK + pointCurrent.deltaK) / 2;
-			}
-		}
-
-		// Adjust tangents to ensure monotonic properties
-		var alphaK, betaK, tauK, squaredMagnitude;
-		for (i = 0; i < pointsLen - 1; ++i) {
-			pointCurrent = pointsWithTangents[i];
-			pointAfter = pointsWithTangents[i + 1];
-			if (pointCurrent.model.skip || pointAfter.model.skip) {
-				continue;
-			}
-
-			if (helpers.almostEquals(pointCurrent.deltaK, 0, this.EPSILON)) {
-				pointCurrent.mK = pointAfter.mK = 0;
-				continue;
-			}
-
-			alphaK = pointCurrent.mK / pointCurrent.deltaK;
-			betaK = pointAfter.mK / pointCurrent.deltaK;
-			squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);
-			if (squaredMagnitude <= 9) {
-				continue;
-			}
-
-			tauK = 3 / Math.sqrt(squaredMagnitude);
-			pointCurrent.mK = alphaK * tauK * pointCurrent.deltaK;
-			pointAfter.mK = betaK * tauK * pointCurrent.deltaK;
-		}
-
-		// Compute control points
-		var deltaX;
-		for (i = 0; i < pointsLen; ++i) {
-			pointCurrent = pointsWithTangents[i];
-			if (pointCurrent.model.skip) {
-				continue;
-			}
-
-			pointBefore = i > 0 ? pointsWithTangents[i - 1] : null;
-			pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null;
-			if (pointBefore && !pointBefore.model.skip) {
-				deltaX = (pointCurrent.model.x - pointBefore.model.x) / 3;
-				pointCurrent.model.controlPointPreviousX = pointCurrent.model.x - deltaX;
-				pointCurrent.model.controlPointPreviousY = pointCurrent.model.y - deltaX * pointCurrent.mK;
-			}
-			if (pointAfter && !pointAfter.model.skip) {
-				deltaX = (pointAfter.model.x - pointCurrent.model.x) / 3;
-				pointCurrent.model.controlPointNextX = pointCurrent.model.x + deltaX;
-				pointCurrent.model.controlPointNextY = pointCurrent.model.y + deltaX * pointCurrent.mK;
-			}
-		}
-	};
-	helpers.nextItem = function(collection, index, loop) {
-		if (loop) {
-			return index >= collection.length - 1 ? collection[0] : collection[index + 1];
-		}
-		return index >= collection.length - 1 ? collection[collection.length - 1] : collection[index + 1];
-	};
-	helpers.previousItem = function(collection, index, loop) {
-		if (loop) {
-			return index <= 0 ? collection[collection.length - 1] : collection[index - 1];
-		}
-		return index <= 0 ? collection[0] : collection[index - 1];
-	};
-	// Implementation of the nice number algorithm used in determining where axis labels will go
-	helpers.niceNum = function(range, round) {
-		var exponent = Math.floor(helpers.log10(range));
-		var fraction = range / Math.pow(10, exponent);
-		var niceFraction;
-
-		if (round) {
-			if (fraction < 1.5) {
-				niceFraction = 1;
-			} else if (fraction < 3) {
-				niceFraction = 2;
-			} else if (fraction < 7) {
-				niceFraction = 5;
-			} else {
-				niceFraction = 10;
-			}
-		} else if (fraction <= 1.0) {
-			niceFraction = 1;
-		} else if (fraction <= 2) {
-			niceFraction = 2;
-		} else if (fraction <= 5) {
-			niceFraction = 5;
-		} else {
-			niceFraction = 10;
-		}
-
-		return niceFraction * Math.pow(10, exponent);
-	};
 	// -- DOM methods
 	helpers.getRelativePosition = function(evt, chart) {
 		var mouseX, mouseY;
diff --git a/src/core/core.scale.js b/src/core/core.scale.js
index 5a2df626326..efadff34412 100644
--- a/src/core/core.scale.js
+++ b/src/core/core.scale.js
@@ -332,7 +332,7 @@ module.exports = Element.extend({
 
 			// Max label rotation can be set or default to 90 - also act as a loop counter
 			while (labelWidth > tickWidth && labelRotation < tickOpts.maxRotation) {
-				var angleRadians = helpers.toRadians(labelRotation);
+				var angleRadians = helpers.math.toRadians(labelRotation);
 				cosRotation = Math.cos(angleRadians);
 				sinRotation = Math.sin(angleRadians);
 
@@ -422,7 +422,7 @@ module.exports = Element.extend({
 				// A horizontal axis is more constrained by the height.
 				me.longestLabelWidth = largestTextWidth;
 
-				var angleRadians = helpers.toRadians(me.labelRotation);
+				var angleRadians = helpers.math.toRadians(me.labelRotation);
 				var cosRotation = Math.cos(angleRadians);
 				var sinRotation = Math.sin(angleRadians);
 
@@ -621,7 +621,7 @@ module.exports = Element.extend({
 		var tickCount = ticks.length;
 
 		// Calculate space needed by label in axis direction.
-		var rot = helpers.toRadians(me.labelRotation);
+		var rot = helpers.math.toRadians(me.labelRotation);
 		var cos = Math.abs(Math.cos(rot));
 		var sin = Math.abs(Math.sin(rot));
 
@@ -743,12 +743,12 @@ module.exports = Element.extend({
 		var scaleLabelFontColor = helpers.valueOrDefault(scaleLabel.fontColor, defaultFontColor);
 		var scaleLabelFont = parseFont(scaleLabel);
 		var scaleLabelPadding = helpers.options.toPadding(scaleLabel.padding);
-		var labelRotationRadians = helpers.toRadians(me.labelRotation);
+		var labelRotationRadians = helpers.math.toRadians(me.labelRotation);
 
 		var itemsToDraw = [];
 
 		var axisWidth = gridLines.drawBorder ? helpers.valueAtIndexOrDefault(gridLines.lineWidth, 0, 0) : 0;
-		var alignPixel = helpers._alignPixel;
+		var alignPixel = helpers.math._alignPixel;
 		var borderValue, tickStart, tickEnd;
 
 		if (position === 'top') {
diff --git a/src/core/core.ticks.js b/src/core/core.ticks.js
index f63e525983a..9e78e0b645d 100644
--- a/src/core/core.ticks.js
+++ b/src/core/core.ticks.js
@@ -42,13 +42,13 @@ module.exports = {
 				}
 			}
 
-			var logDelta = helpers.log10(Math.abs(delta));
+			var logDelta = helpers.math.log10(Math.abs(delta));
 			var tickString = '';
 
 			if (tickValue !== 0) {
 				var maxTick = Math.max(Math.abs(ticks[0]), Math.abs(ticks[ticks.length - 1]));
 				if (maxTick < 1e-4) { // all ticks are small numbers; use scientific notation
-					var logTick = helpers.log10(Math.abs(tickValue));
+					var logTick = helpers.math.log10(Math.abs(tickValue));
 					tickString = tickValue.toExponential(Math.floor(logTick) - Math.floor(logDelta));
 				} else {
 					var numDecimal = -1 * Math.floor(logDelta);
@@ -63,7 +63,7 @@ module.exports = {
 		},
 
 		logarithmic: function(tickValue, index, ticks) {
-			var remain = tickValue / (Math.pow(10, Math.floor(helpers.log10(tickValue))));
+			var remain = tickValue / (Math.pow(10, Math.floor(helpers.math.log10(tickValue))));
 
 			if (tickValue === 0) {
 				return '0';
diff --git a/src/core/core.tooltip.js b/src/core/core.tooltip.js
index 340d7c90868..7289bf759e6 100644
--- a/src/core/core.tooltip.js
+++ b/src/core/core.tooltip.js
@@ -146,7 +146,7 @@ var positioners = {
 			var el = elements[i];
 			if (el && el.hasValue()) {
 				var center = el.getCenterPoint();
-				var d = helpers.distanceBetweenPoints(eventPosition, center);
+				var d = helpers.math.distanceBetweenPoints(eventPosition, center);
 
 				if (d < minDistance) {
 					minDistance = d;
diff --git a/src/elements/element.arc.js b/src/elements/element.arc.js
index 82d836c6b80..6b7c57c4c86 100644
--- a/src/elements/element.arc.js
+++ b/src/elements/element.arc.js
@@ -29,7 +29,7 @@ module.exports = Element.extend({
 		var vm = this._view;
 
 		if (vm) {
-			var pointRelativePosition = helpers.getAngleFromPoint(vm, {x: chartX, y: chartY});
+			var pointRelativePosition = helpers.math.getAngleFromPoint(vm, {x: chartX, y: chartY});
 			var	angle = pointRelativePosition.angle;
 			var distance = pointRelativePosition.distance;
 
diff --git a/src/elements/element.line.js b/src/elements/element.line.js
index 96bb5be383e..bfb2feae9a4 100644
--- a/src/elements/element.line.js
+++ b/src/elements/element.line.js
@@ -61,7 +61,7 @@ module.exports = Element.extend({
 
 		for (index = 0; index < points.length; ++index) {
 			current = points[index];
-			previous = helpers.previousItem(points, index);
+			previous = helpers.math.previousItem(points, index);
 			currentVM = current._view;
 
 			// First point moves to it's starting position no matter what
diff --git a/src/helpers/helpers.math.js b/src/helpers/helpers.math.js
new file mode 100644
index 00000000000..4efee0d2cd9
--- /dev/null
+++ b/src/helpers/helpers.math.js
@@ -0,0 +1,281 @@
+'use strict';
+
+var helpers = require('./helpers.core');
+
+/**
+ * @namespace Chart.helpers.math
+ */
+module.exports = {
+	isNumber: function(n) {
+		return !isNaN(parseFloat(n)) && isFinite(n);
+	},
+	almostEquals: function(x, y, epsilon) {
+		return Math.abs(x - y) < epsilon;
+	},
+	almostWhole: function(x, epsilon) {
+		var rounded = Math.round(x);
+		return (((rounded - epsilon) < x) && ((rounded + epsilon) > x));
+	},
+	max: function(array) {
+		return array.reduce(function(max, value) {
+			if (!isNaN(value)) {
+				return Math.max(max, value);
+			}
+			return max;
+		}, Number.NEGATIVE_INFINITY);
+	},
+	min: function(array) {
+		return array.reduce(function(min, value) {
+			if (!isNaN(value)) {
+				return Math.min(min, value);
+			}
+			return min;
+		}, Number.POSITIVE_INFINITY);
+	},
+	sign: Math.sign ?
+		function(x) {
+			return Math.sign(x);
+		} :
+		function(x) {
+			x = +x; // convert to a number
+			if (x === 0 || isNaN(x)) {
+				return x;
+			}
+			return x > 0 ? 1 : -1;
+		},
+	log10: Math.log10 ?
+		function(x) {
+			return Math.log10(x);
+		} :
+		function(x) {
+			var exponent = Math.log(x) * Math.LOG10E; // Math.LOG10E = 1 / Math.LN10.
+			// Check for whole powers of 10,
+			// which due to floating point rounding error should be corrected.
+			var powerOf10 = Math.round(exponent);
+			var isPowerOf10 = x === Math.pow(10, powerOf10);
+
+			return isPowerOf10 ? powerOf10 : exponent;
+		},
+	toRadians: function(degrees) {
+		return degrees * (Math.PI / 180);
+	},
+	toDegrees: function(radians) {
+		return radians * (180 / Math.PI);
+	},
+
+	/**
+	 * Returns the number of decimal places
+	 * i.e. the number of digits after the decimal point, of the value of this Number.
+	 * @param {Number} x - A number.
+	 * @returns {Number} The number of decimal places.
+	 */
+	decimalPlaces: function(x) {
+		if (!helpers.isFinite(x)) {
+			return;
+		}
+		var e = 1;
+		var p = 0;
+		while (Math.round(x * e) / e !== x) {
+			e *= 10;
+			p++;
+		}
+		return p;
+	},
+
+	// Gets the angle from vertical upright to the point about a centre.
+	getAngleFromPoint: function(centrePoint, anglePoint) {
+		var distanceFromXCenter = anglePoint.x - centrePoint.x;
+		var distanceFromYCenter = anglePoint.y - centrePoint.y;
+		var radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
+
+		var angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
+
+		if (angle < (-0.5 * Math.PI)) {
+			angle += 2.0 * Math.PI; // make sure the returned angle is in the range of (-PI/2, 3PI/2]
+		}
+
+		return {
+			angle: angle,
+			distance: radialDistanceFromCenter
+		};
+	},
+	distanceBetweenPoints: function(pt1, pt2) {
+		return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
+	},
+	aliasPixel: function(pixelWidth) {
+		return (pixelWidth % 2 === 0) ? 0 : 0.5;
+	},
+
+	_alignPixel: function(chart, pixel, width) {
+		var devicePixelRatio = chart.currentDevicePixelRatio;
+		var halfWidth = width / 2;
+		return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;
+	},
+
+	splineCurve: function(firstPoint, middlePoint, afterPoint, t) {
+		// Props to Rob Spencer at scaled innovation for his post on splining between points
+		// http://scaledinnovation.com/analytics/splines/aboutSplines.html
+
+		// This function must also respect "skipped" points
+
+		var previous = firstPoint.skip ? middlePoint : firstPoint;
+		var current = middlePoint;
+		var next = afterPoint.skip ? middlePoint : afterPoint;
+
+		var d01 = Math.sqrt(Math.pow(current.x - previous.x, 2) + Math.pow(current.y - previous.y, 2));
+		var d12 = Math.sqrt(Math.pow(next.x - current.x, 2) + Math.pow(next.y - current.y, 2));
+
+		var s01 = d01 / (d01 + d12);
+		var s12 = d12 / (d01 + d12);
+
+		// If all points are the same, s01 & s02 will be inf
+		s01 = isNaN(s01) ? 0 : s01;
+		s12 = isNaN(s12) ? 0 : s12;
+
+		var fa = t * s01; // scaling factor for triangle Ta
+		var fb = t * s12;
+
+		return {
+			previous: {
+				x: current.x - fa * (next.x - previous.x),
+				y: current.y - fa * (next.y - previous.y)
+			},
+			next: {
+				x: current.x + fb * (next.x - previous.x),
+				y: current.y + fb * (next.y - previous.y)
+			}
+		};
+	},
+	EPSILON: Number.EPSILON || 1e-14,
+	splineCurveMonotone: function(points) {
+		// This function calculates Bézier control points in a similar way than |splineCurve|,
+		// but preserves monotonicity of the provided data and ensures no local extremums are added
+		// between the dataset discrete points due to the interpolation.
+		// See : https://en.wikipedia.org/wiki/Monotone_cubic_interpolation
+
+		var pointsWithTangents = (points || []).map(function(point) {
+			return {
+				model: point._model,
+				deltaK: 0,
+				mK: 0
+			};
+		});
+
+		// Calculate slopes (deltaK) and initialize tangents (mK)
+		var pointsLen = pointsWithTangents.length;
+		var i, pointBefore, pointCurrent, pointAfter;
+		for (i = 0; i < pointsLen; ++i) {
+			pointCurrent = pointsWithTangents[i];
+			if (pointCurrent.model.skip) {
+				continue;
+			}
+
+			pointBefore = i > 0 ? pointsWithTangents[i - 1] : null;
+			pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null;
+			if (pointAfter && !pointAfter.model.skip) {
+				var slopeDeltaX = (pointAfter.model.x - pointCurrent.model.x);
+
+				// In the case of two points that appear at the same x pixel, slopeDeltaX is 0
+				pointCurrent.deltaK = slopeDeltaX !== 0 ? (pointAfter.model.y - pointCurrent.model.y) / slopeDeltaX : 0;
+			}
+
+			if (!pointBefore || pointBefore.model.skip) {
+				pointCurrent.mK = pointCurrent.deltaK;
+			} else if (!pointAfter || pointAfter.model.skip) {
+				pointCurrent.mK = pointBefore.deltaK;
+			} else if (this.sign(pointBefore.deltaK) !== this.sign(pointCurrent.deltaK)) {
+				pointCurrent.mK = 0;
+			} else {
+				pointCurrent.mK = (pointBefore.deltaK + pointCurrent.deltaK) / 2;
+			}
+		}
+
+		// Adjust tangents to ensure monotonic properties
+		var alphaK, betaK, tauK, squaredMagnitude;
+		for (i = 0; i < pointsLen - 1; ++i) {
+			pointCurrent = pointsWithTangents[i];
+			pointAfter = pointsWithTangents[i + 1];
+			if (pointCurrent.model.skip || pointAfter.model.skip) {
+				continue;
+			}
+
+			if (helpers.math.almostEquals(pointCurrent.deltaK, 0, this.EPSILON)) {
+				pointCurrent.mK = pointAfter.mK = 0;
+				continue;
+			}
+
+			alphaK = pointCurrent.mK / pointCurrent.deltaK;
+			betaK = pointAfter.mK / pointCurrent.deltaK;
+			squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);
+			if (squaredMagnitude <= 9) {
+				continue;
+			}
+
+			tauK = 3 / Math.sqrt(squaredMagnitude);
+			pointCurrent.mK = alphaK * tauK * pointCurrent.deltaK;
+			pointAfter.mK = betaK * tauK * pointCurrent.deltaK;
+		}
+
+		// Compute control points
+		var deltaX;
+		for (i = 0; i < pointsLen; ++i) {
+			pointCurrent = pointsWithTangents[i];
+			if (pointCurrent.model.skip) {
+				continue;
+			}
+
+			pointBefore = i > 0 ? pointsWithTangents[i - 1] : null;
+			pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null;
+			if (pointBefore && !pointBefore.model.skip) {
+				deltaX = (pointCurrent.model.x - pointBefore.model.x) / 3;
+				pointCurrent.model.controlPointPreviousX = pointCurrent.model.x - deltaX;
+				pointCurrent.model.controlPointPreviousY = pointCurrent.model.y - deltaX * pointCurrent.mK;
+			}
+			if (pointAfter && !pointAfter.model.skip) {
+				deltaX = (pointAfter.model.x - pointCurrent.model.x) / 3;
+				pointCurrent.model.controlPointNextX = pointCurrent.model.x + deltaX;
+				pointCurrent.model.controlPointNextY = pointCurrent.model.y + deltaX * pointCurrent.mK;
+			}
+		}
+	},
+	nextItem: function(collection, index, loop) {
+		if (loop) {
+			return index >= collection.length - 1 ? collection[0] : collection[index + 1];
+		}
+		return index >= collection.length - 1 ? collection[collection.length - 1] : collection[index + 1];
+	},
+	previousItem: function(collection, index, loop) {
+		if (loop) {
+			return index <= 0 ? collection[collection.length - 1] : collection[index - 1];
+		}
+		return index <= 0 ? collection[0] : collection[index - 1];
+	},
+	// Implementation of the nice number algorithm used in determining where axis labels will go
+	niceNum: function(range, round) {
+		var exponent = Math.floor(helpers.math.log10(range));
+		var fraction = range / Math.pow(10, exponent);
+		var niceFraction;
+
+		if (round) {
+			if (fraction < 1.5) {
+				niceFraction = 1;
+			} else if (fraction < 3) {
+				niceFraction = 2;
+			} else if (fraction < 7) {
+				niceFraction = 5;
+			} else {
+				niceFraction = 10;
+			}
+		} else if (fraction <= 1.0) {
+			niceFraction = 1;
+		} else if (fraction <= 2) {
+			niceFraction = 2;
+		} else if (fraction <= 5) {
+			niceFraction = 5;
+		} else {
+			niceFraction = 10;
+		}
+
+		return niceFraction * Math.pow(10, exponent);
+	}
+};
diff --git a/src/helpers/index.js b/src/helpers/index.js
index 60c199cad55..ef510076090 100644
--- a/src/helpers/index.js
+++ b/src/helpers/index.js
@@ -4,3 +4,4 @@ module.exports = require('./helpers.core');
 module.exports.easing = require('./helpers.easing');
 module.exports.canvas = require('./helpers.canvas');
 module.exports.options = require('./helpers.options');
+module.exports.math = require('./helpers.math');
diff --git a/src/scales/scale.linear.js b/src/scales/scale.linear.js
index 41a4e4168a3..bc3c9356501 100644
--- a/src/scales/scale.linear.js
+++ b/src/scales/scale.linear.js
@@ -91,8 +91,8 @@ module.exports = LinearScaleBase.extend({
 
 			helpers.each(valuesPerStack, function(valuesForType) {
 				var values = valuesForType.positiveValues.concat(valuesForType.negativeValues);
-				var minVal = helpers.min(values);
-				var maxVal = helpers.max(values);
+				var minVal = helpers.math.min(values);
+				var maxVal = helpers.math.max(values);
 				me.min = me.min === null ? minVal : Math.min(me.min, minVal);
 				me.max = me.max === null ? maxVal : Math.max(me.max, maxVal);
 			});
diff --git a/src/scales/scale.linearbase.js b/src/scales/scale.linearbase.js
index 808f454407a..205fe0d4f13 100644
--- a/src/scales/scale.linearbase.js
+++ b/src/scales/scale.linearbase.js
@@ -27,16 +27,16 @@ function generateTicks(generationOptions, dataRange) {
 
 	// spacing is set to a nice number of the dataRange divided by maxNumSpaces.
 	// stepSize is used as a minimum unit if it is specified.
-	spacing = helpers.niceNum((dataRange.max - dataRange.min) / maxNumSpaces / unit) * unit;
+	spacing = helpers.math.niceNum((dataRange.max - dataRange.min) / maxNumSpaces / unit) * unit;
 	numSpaces = Math.ceil(dataRange.max / spacing) - Math.floor(dataRange.min / spacing);
 	if (numSpaces > maxNumSpaces) {
 		// If the calculated num of spaces exceeds maxNumSpaces, recalculate it
-		spacing = helpers.niceNum(numSpaces * spacing / maxNumSpaces / unit) * unit;
+		spacing = helpers.math.niceNum(numSpaces * spacing / maxNumSpaces / unit) * unit;
 	}
 
 	if (stepSize || helpers.isNullOrUndef(precision)) {
 		// If a precision is not specified, calculate factor based on spacing
-		factor = Math.pow(10, helpers.decimalPlaces(spacing));
+		factor = Math.pow(10, helpers.math.decimalPlaces(spacing));
 	} else {
 		// If the user specified a precision, round to that number of decimal places
 		factor = Math.pow(10, precision);
@@ -49,17 +49,17 @@ function generateTicks(generationOptions, dataRange) {
 	// If min, max and stepSize is set and they make an evenly spaced scale use it.
 	if (stepSize) {
 		// If very close to our whole number, use it.
-		if (!helpers.isNullOrUndef(min) && helpers.almostWhole(min / spacing, spacing / 1000)) {
+		if (!helpers.isNullOrUndef(min) && helpers.math.almostWhole(min / spacing, spacing / 1000)) {
 			niceMin = min;
 		}
-		if (!helpers.isNullOrUndef(max) && helpers.almostWhole(max / spacing, spacing / 1000)) {
+		if (!helpers.isNullOrUndef(max) && helpers.math.almostWhole(max / spacing, spacing / 1000)) {
 			niceMax = max;
 		}
 	}
 
 	numSpaces = (niceMax - niceMin) / spacing;
 	// If very close to our rounded value, use it.
-	if (helpers.almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {
+	if (helpers.math.almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {
 		numSpaces = Math.round(numSpaces);
 	} else {
 		numSpaces = Math.ceil(numSpaces);
@@ -93,8 +93,8 @@ module.exports = Scale.extend({
 		// do nothing since that would make the chart weird. If the user really wants a weird chart
 		// axis, they can manually override it
 		if (tickOpts.beginAtZero) {
-			var minSign = helpers.sign(me.min);
-			var maxSign = helpers.sign(me.max);
+			var minSign = helpers.math.sign(me.min);
+			var maxSign = helpers.math.sign(me.max);
 
 			if (minSign < 0 && maxSign < 0) {
 				// move the top up to 0
@@ -203,8 +203,8 @@ module.exports = Scale.extend({
 
 		// At this point, we need to update our max and min given the tick values since we have expanded the
 		// range of the scale
-		me.max = helpers.max(ticks);
-		me.min = helpers.min(ticks);
+		me.max = helpers.math.max(ticks);
+		me.min = helpers.math.min(ticks);
 
 		if (tickOpts.reverse) {
 			ticks.reverse();
diff --git a/src/scales/scale.logarithmic.js b/src/scales/scale.logarithmic.js
index 5dd5fe80e30..3f01358fb5f 100644
--- a/src/scales/scale.logarithmic.js
+++ b/src/scales/scale.logarithmic.js
@@ -15,20 +15,20 @@ function generateTicks(generationOptions, dataRange) {
 	var ticks = [];
 	var valueOrDefault = helpers.valueOrDefault;
 
-	var tickVal = valueOrDefault(generationOptions.min, Math.pow(10, Math.floor(helpers.log10(dataRange.min))));
+	var tickVal = valueOrDefault(generationOptions.min, Math.pow(10, Math.floor(helpers.math.log10(dataRange.min))));
 
-	var endExp = Math.floor(helpers.log10(dataRange.max));
+	var endExp = Math.floor(helpers.math.log10(dataRange.max));
 	var endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp));
 	var exp, significand;
 
 	if (tickVal === 0) {
-		exp = Math.floor(helpers.log10(dataRange.minNotZero));
+		exp = Math.floor(helpers.math.log10(dataRange.minNotZero));
 		significand = Math.floor(dataRange.minNotZero / Math.pow(10, exp));
 
 		ticks.push(tickVal);
 		tickVal = significand * Math.pow(10, exp);
 	} else {
-		exp = Math.floor(helpers.log10(tickVal));
+		exp = Math.floor(helpers.math.log10(tickVal));
 		significand = Math.floor(tickVal / Math.pow(10, exp));
 	}
 	var precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;
@@ -125,8 +125,8 @@ module.exports = Scale.extend({
 
 			helpers.each(valuesPerStack, function(valuesForType) {
 				if (valuesForType.length > 0) {
-					var minVal = helpers.min(valuesForType);
-					var maxVal = helpers.max(valuesForType);
+					var minVal = helpers.math.min(valuesForType);
+					var maxVal = helpers.math.max(valuesForType);
 					me.min = me.min === null ? minVal : Math.min(me.min, minVal);
 					me.max = me.max === null ? maxVal : Math.max(me.max, maxVal);
 				}
@@ -180,26 +180,26 @@ module.exports = Scale.extend({
 
 		if (me.min === me.max) {
 			if (me.min !== 0 && me.min !== null) {
-				me.min = Math.pow(10, Math.floor(helpers.log10(me.min)) - 1);
-				me.max = Math.pow(10, Math.floor(helpers.log10(me.max)) + 1);
+				me.min = Math.pow(10, Math.floor(helpers.math.log10(me.min)) - 1);
+				me.max = Math.pow(10, Math.floor(helpers.math.log10(me.max)) + 1);
 			} else {
 				me.min = DEFAULT_MIN;
 				me.max = DEFAULT_MAX;
 			}
 		}
 		if (me.min === null) {
-			me.min = Math.pow(10, Math.floor(helpers.log10(me.max)) - 1);
+			me.min = Math.pow(10, Math.floor(helpers.math.log10(me.max)) - 1);
 		}
 		if (me.max === null) {
 			me.max = me.min !== 0
-				? Math.pow(10, Math.floor(helpers.log10(me.min)) + 1)
+				? Math.pow(10, Math.floor(helpers.math.log10(me.min)) + 1)
 				: DEFAULT_MAX;
 		}
 		if (me.minNotZero === null) {
 			if (me.min > 0) {
 				me.minNotZero = me.min;
 			} else if (me.max < 1) {
-				me.minNotZero = Math.pow(10, Math.floor(helpers.log10(me.max)));
+				me.minNotZero = Math.pow(10, Math.floor(helpers.math.log10(me.max)));
 			} else {
 				me.minNotZero = DEFAULT_MIN;
 			}
@@ -220,8 +220,8 @@ module.exports = Scale.extend({
 
 		// At this point, we need to update our max and min given the tick values since we have expanded the
 		// range of the scale
-		me.max = helpers.max(ticks);
-		me.min = helpers.min(ticks);
+		me.max = helpers.math.max(ticks);
+		me.min = helpers.math.min(ticks);
 
 		if (tickOpts.reverse) {
 			reverse = !reverse;
@@ -258,7 +258,7 @@ module.exports = Scale.extend({
 	 * @private
 	 */
 	_getFirstTickValue: function(value) {
-		var exp = Math.floor(helpers.log10(value));
+		var exp = Math.floor(helpers.math.log10(value));
 		var significand = Math.floor(value / Math.pow(10, exp));
 
 		return significand * Math.pow(10, exp);
@@ -267,7 +267,7 @@ module.exports = Scale.extend({
 	getPixelForValue: function(value) {
 		var me = this;
 		var reverse = me.options.ticks.reverse;
-		var log10 = helpers.log10;
+		var log10 = helpers.math.log10;
 		var firstTickValue = me._getFirstTickValue(me.minNotZero);
 		var offset = 0;
 		var innerDimension, pixel, start, end, sign;
@@ -310,7 +310,7 @@ module.exports = Scale.extend({
 	getValueForPixel: function(pixel) {
 		var me = this;
 		var reverse = me.options.ticks.reverse;
-		var log10 = helpers.log10;
+		var log10 = helpers.math.log10;
 		var firstTickValue = me._getFirstTickValue(me.minNotZero);
 		var innerDimension, start, end, value;
 
diff --git a/src/scales/scale.radialLinear.js b/src/scales/scale.radialLinear.js
index 703c9911ba9..7eaf913d7a1 100644
--- a/src/scales/scale.radialLinear.js
+++ b/src/scales/scale.radialLinear.js
@@ -157,7 +157,7 @@ function fitWithPointLabels(scale) {
 
 		// Add quarter circle to make degree 0 mean top of circle
 		var angleRadians = scale.getIndexAngle(i);
-		var angle = helpers.toDegrees(angleRadians) % 360;
+		var angle = helpers.math.toDegrees(angleRadians) % 360;
 		var hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);
 		var vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);
 
@@ -262,7 +262,7 @@ function drawPointLabels(scale) {
 			ctx.fillStyle = pointLabelFontColor;
 
 			var angleRadians = scale.getIndexAngle(i);
-			var angle = helpers.toDegrees(angleRadians);
+			var angle = helpers.math.toDegrees(angleRadians);
 			ctx.textAlign = getTextAlignForAngle(angle);
 			adjustPointPositionForLabelHeight(angle, scale._pointLabelSizes[i], pointLabelPosition);
 			fillText(ctx, scale.pointLabels[i] || '', pointLabelPosition, plFont.lineHeight);
@@ -311,7 +311,7 @@ function drawRadiusLine(scale, gridLineOpts, radius, index) {
 }
 
 function numberOrZero(param) {
-	return helpers.isNumber(param) ? param : 0;
+	return helpers.math.isNumber(param) ? param : 0;
 }
 
 module.exports = LinearScaleBase.extend({
diff --git a/src/scales/scale.time.js b/src/scales/scale.time.js
index c7c49eb6b1b..9b03f247c0e 100644
--- a/src/scales/scale.time.js
+++ b/src/scales/scale.time.js
@@ -762,7 +762,7 @@ module.exports = Scale.extend({
 		var me = this;
 		var ticksOpts = me.options.ticks;
 		var tickLabelWidth = me.ctx.measureText(label).width;
-		var angle = helpers.toRadians(ticksOpts.maxRotation);
+		var angle = helpers.math.toRadians(ticksOpts.maxRotation);
 		var cosRotation = Math.cos(angle);
 		var sinRotation = Math.sin(angle);
 		var tickFontSize = helpers.valueOrDefault(ticksOpts.fontSize, defaults.global.defaultFontSize);
diff --git a/test/specs/core.helpers.tests.js b/test/specs/core.helpers.tests.js
index 43104b07dbd..932e4c39ad1 100644
--- a/test/specs/core.helpers.tests.js
+++ b/test/specs/core.helpers.tests.js
@@ -186,34 +186,6 @@ describe('Core helper tests', function() {
 		expect(helpers.findPreviousWhere(data, callback, 0)).toBe(undefined);
 	});
 
-	it('should get the correct sign', function() {
-		expect(helpers.sign(0)).toBe(0);
-		expect(helpers.sign(10)).toBe(1);
-		expect(helpers.sign(-5)).toBe(-1);
-	});
-
-	it('should do a log10 operation', function() {
-		expect(helpers.log10(0)).toBe(-Infinity);
-
-		// Check all allowed powers of 10, which should return integer values
-		var maxPowerOf10 = Math.floor(helpers.log10(Number.MAX_VALUE));
-		for (var i = 0; i < maxPowerOf10; i += 1) {
-			expect(helpers.log10(Math.pow(10, i))).toBe(i);
-		}
-	});
-
-	it('should correctly determine if two numbers are essentially equal', function() {
-		expect(helpers.almostEquals(0, Number.EPSILON, 2 * Number.EPSILON)).toBe(true);
-		expect(helpers.almostEquals(1, 1.1, 0.0001)).toBe(false);
-		expect(helpers.almostEquals(1e30, 1e30 + Number.EPSILON, 0)).toBe(false);
-		expect(helpers.almostEquals(1e30, 1e30 + Number.EPSILON, 2 * Number.EPSILON)).toBe(true);
-	});
-
-	it('should correctly determine if a numbers are essentially whole', function() {
-		expect(helpers.almostWhole(0.99999, 0.0001)).toBe(true);
-		expect(helpers.almostWhole(0.9, 0.0001)).toBe(false);
-	});
-
 	it('should generate integer ids', function() {
 		var uid = helpers.uid();
 		expect(uid).toEqual(jasmine.any(Number));
@@ -222,283 +194,6 @@ describe('Core helper tests', function() {
 		expect(helpers.uid()).toBe(uid + 3);
 	});
 
-	it('should detect a number', function() {
-		expect(helpers.isNumber(123)).toBe(true);
-		expect(helpers.isNumber('123')).toBe(true);
-		expect(helpers.isNumber(null)).toBe(false);
-		expect(helpers.isNumber(NaN)).toBe(false);
-		expect(helpers.isNumber(undefined)).toBe(false);
-		expect(helpers.isNumber('cbc')).toBe(false);
-	});
-
-	it('should convert between radians and degrees', function() {
-		expect(helpers.toRadians(180)).toBe(Math.PI);
-		expect(helpers.toRadians(90)).toBe(0.5 * Math.PI);
-		expect(helpers.toDegrees(Math.PI)).toBe(180);
-		expect(helpers.toDegrees(Math.PI * 3 / 2)).toBe(270);
-	});
-
-	it('should get the correct number of decimal places', function() {
-		expect(helpers.decimalPlaces(100)).toBe(0);
-		expect(helpers.decimalPlaces(1)).toBe(0);
-		expect(helpers.decimalPlaces(0)).toBe(0);
-		expect(helpers.decimalPlaces(0.01)).toBe(2);
-		expect(helpers.decimalPlaces(-0.01)).toBe(2);
-		expect(helpers.decimalPlaces('1')).toBe(undefined);
-		expect(helpers.decimalPlaces('')).toBe(undefined);
-		expect(helpers.decimalPlaces(undefined)).toBe(undefined);
-	});
-
-	it('should get an angle from a point', function() {
-		var center = {
-			x: 0,
-			y: 0
-		};
-
-		expect(helpers.getAngleFromPoint(center, {
-			x: 0,
-			y: 10
-		})).toEqual({
-			angle: Math.PI / 2,
-			distance: 10,
-		});
-
-		expect(helpers.getAngleFromPoint(center, {
-			x: Math.sqrt(2),
-			y: Math.sqrt(2)
-		})).toEqual({
-			angle: Math.PI / 4,
-			distance: 2
-		});
-
-		expect(helpers.getAngleFromPoint(center, {
-			x: -1.0 * Math.sqrt(2),
-			y: -1.0 * Math.sqrt(2)
-		})).toEqual({
-			angle: Math.PI * 1.25,
-			distance: 2
-		});
-	});
-
-	it('should spline curves', function() {
-		expect(helpers.splineCurve({
-			x: 0,
-			y: 0
-		}, {
-			x: 1,
-			y: 1
-		}, {
-			x: 2,
-			y: 0
-		}, 0)).toEqual({
-			previous: {
-				x: 1,
-				y: 1,
-			},
-			next: {
-				x: 1,
-				y: 1,
-			}
-		});
-
-		expect(helpers.splineCurve({
-			x: 0,
-			y: 0
-		}, {
-			x: 1,
-			y: 1
-		}, {
-			x: 2,
-			y: 0
-		}, 1)).toEqual({
-			previous: {
-				x: 0,
-				y: 1,
-			},
-			next: {
-				x: 2,
-				y: 1,
-			}
-		});
-	});
-
-	it('should spline curves with monotone cubic interpolation', function() {
-		var dataPoints = [
-			{_model: {x: 0, y: 0, skip: false}},
-			{_model: {x: 3, y: 6, skip: false}},
-			{_model: {x: 9, y: 6, skip: false}},
-			{_model: {x: 12, y: 60, skip: false}},
-			{_model: {x: 15, y: 60, skip: false}},
-			{_model: {x: 18, y: 120, skip: false}},
-			{_model: {x: null, y: null, skip: true}},
-			{_model: {x: 21, y: 180, skip: false}},
-			{_model: {x: 24, y: 120, skip: false}},
-			{_model: {x: 27, y: 125, skip: false}},
-			{_model: {x: 30, y: 105, skip: false}},
-			{_model: {x: 33, y: 110, skip: false}},
-			{_model: {x: 33, y: 110, skip: false}},
-			{_model: {x: 36, y: 170, skip: false}}
-		];
-		helpers.splineCurveMonotone(dataPoints);
-		expect(dataPoints).toEqual([{
-			_model: {
-				x: 0,
-				y: 0,
-				skip: false,
-				controlPointNextX: 1,
-				controlPointNextY: 2
-			}
-		},
-		{
-			_model: {
-				x: 3,
-				y: 6,
-				skip: false,
-				controlPointPreviousX: 2,
-				controlPointPreviousY: 6,
-				controlPointNextX: 5,
-				controlPointNextY: 6
-			}
-		},
-		{
-			_model: {
-				x: 9,
-				y: 6,
-				skip: false,
-				controlPointPreviousX: 7,
-				controlPointPreviousY: 6,
-				controlPointNextX: 10,
-				controlPointNextY: 6
-			}
-		},
-		{
-			_model: {
-				x: 12,
-				y: 60,
-				skip: false,
-				controlPointPreviousX: 11,
-				controlPointPreviousY: 60,
-				controlPointNextX: 13,
-				controlPointNextY: 60
-			}
-		},
-		{
-			_model: {
-				x: 15,
-				y: 60,
-				skip: false,
-				controlPointPreviousX: 14,
-				controlPointPreviousY: 60,
-				controlPointNextX: 16,
-				controlPointNextY: 60
-			}
-		},
-		{
-			_model: {
-				x: 18,
-				y: 120,
-				skip: false,
-				controlPointPreviousX: 17,
-				controlPointPreviousY: 100
-			}
-		},
-		{
-			_model: {
-				x: null,
-				y: null,
-				skip: true
-			}
-		},
-		{
-			_model: {
-				x: 21,
-				y: 180,
-				skip: false,
-				controlPointNextX: 22,
-				controlPointNextY: 160
-			}
-		},
-		{
-			_model: {
-				x: 24,
-				y: 120,
-				skip: false,
-				controlPointPreviousX: 23,
-				controlPointPreviousY: 120,
-				controlPointNextX: 25,
-				controlPointNextY: 120
-			}
-		},
-		{
-			_model: {
-				x: 27,
-				y: 125,
-				skip: false,
-				controlPointPreviousX: 26,
-				controlPointPreviousY: 125,
-				controlPointNextX: 28,
-				controlPointNextY: 125
-			}
-		},
-		{
-			_model: {
-				x: 30,
-				y: 105,
-				skip: false,
-				controlPointPreviousX: 29,
-				controlPointPreviousY: 105,
-				controlPointNextX: 31,
-				controlPointNextY: 105
-			}
-		},
-		{
-			_model: {
-				x: 33,
-				y: 110,
-				skip: false,
-				controlPointPreviousX: 32,
-				controlPointPreviousY: 110,
-				controlPointNextX: 33,
-				controlPointNextY: 110
-			}
-		},
-		{
-			_model: {
-				x: 33,
-				y: 110,
-				skip: false,
-				controlPointPreviousX: 33,
-				controlPointPreviousY: 110,
-				controlPointNextX: 34,
-				controlPointNextY: 110
-			}
-		},
-		{
-			_model: {
-				x: 36,
-				y: 170,
-				skip: false,
-				controlPointPreviousX: 35,
-				controlPointPreviousY: 150
-			}
-		}]);
-	});
-
-	it('should get the next or previous item in an array', function() {
-		var testData = [0, 1, 2];
-
-		expect(helpers.nextItem(testData, 0, false)).toEqual(1);
-		expect(helpers.nextItem(testData, 2, false)).toEqual(2);
-		expect(helpers.nextItem(testData, 2, true)).toEqual(0);
-		expect(helpers.nextItem(testData, 1, true)).toEqual(2);
-		expect(helpers.nextItem(testData, -1, false)).toEqual(0);
-
-		expect(helpers.previousItem(testData, 0, false)).toEqual(0);
-		expect(helpers.previousItem(testData, 0, true)).toEqual(2);
-		expect(helpers.previousItem(testData, 2, false)).toEqual(1);
-		expect(helpers.previousItem(testData, 1, true)).toEqual(0);
-	});
-
 	it ('should get the maximum width and height for a node', function() {
 		// Create div with fixed size as a test bed
 		var div = document.createElement('div');
diff --git a/test/specs/global.deprecations.tests.js b/test/specs/global.deprecations.tests.js
index 822b234b417..4f18c57ee0a 100644
--- a/test/specs/global.deprecations.tests.js
+++ b/test/specs/global.deprecations.tests.js
@@ -25,10 +25,10 @@ describe('Deprecations', function() {
 			});
 		});
 
-		describe('Chart.helpers.aliasPixel', function() {
+		describe('Chart.helpers.math.aliasPixel', function() {
 			it('should be defined and a function', function() {
-				expect(Chart.helpers.aliasPixel).toBeDefined();
-				expect(typeof Chart.helpers.aliasPixel).toBe('function');
+				expect(Chart.helpers.math.aliasPixel).toBeDefined();
+				expect(typeof Chart.helpers.math.aliasPixel).toBe('function');
 			});
 		});
 
diff --git a/test/specs/helpers.math.tests.js b/test/specs/helpers.math.tests.js
new file mode 100644
index 00000000000..26945e2b0fc
--- /dev/null
+++ b/test/specs/helpers.math.tests.js
@@ -0,0 +1,313 @@
+describe('Math helper tests', function() {
+
+	var helpers;
+
+	beforeAll(function() {
+		helpers = window.Chart.helpers;
+	});
+
+	it('should get the correct sign', function() {
+		expect(helpers.math.sign(0)).toBe(0);
+		expect(helpers.math.sign(10)).toBe(1);
+		expect(helpers.math.sign(-5)).toBe(-1);
+	});
+
+	it('should do a log10 operation', function() {
+		expect(helpers.math.log10(0)).toBe(-Infinity);
+
+		// Check all allowed powers of 10, which should return integer values
+		var maxPowerOf10 = Math.floor(helpers.math.log10(Number.MAX_VALUE));
+		for (var i = 0; i < maxPowerOf10; i += 1) {
+			expect(helpers.math.log10(Math.pow(10, i))).toBe(i);
+		}
+	});
+
+	it('should correctly determine if two numbers are essentially equal', function() {
+		expect(helpers.math.almostEquals(0, Number.EPSILON, 2 * Number.EPSILON)).toBe(true);
+		expect(helpers.math.almostEquals(1, 1.1, 0.0001)).toBe(false);
+		expect(helpers.math.almostEquals(1e30, 1e30 + Number.EPSILON, 0)).toBe(false);
+		expect(helpers.math.almostEquals(1e30, 1e30 + Number.EPSILON, 2 * Number.EPSILON)).toBe(true);
+	});
+
+	it('should correctly determine if a numbers are essentially whole', function() {
+		expect(helpers.math.almostWhole(0.99999, 0.0001)).toBe(true);
+		expect(helpers.math.almostWhole(0.9, 0.0001)).toBe(false);
+	});
+
+	it('should detect a number', function() {
+		expect(helpers.math.isNumber(123)).toBe(true);
+		expect(helpers.math.isNumber('123')).toBe(true);
+		expect(helpers.math.isNumber(null)).toBe(false);
+		expect(helpers.math.isNumber(NaN)).toBe(false);
+		expect(helpers.math.isNumber(undefined)).toBe(false);
+		expect(helpers.math.isNumber('cbc')).toBe(false);
+	});
+
+	it('should convert between radians and degrees', function() {
+		expect(helpers.math.toRadians(180)).toBe(Math.PI);
+		expect(helpers.math.toRadians(90)).toBe(0.5 * Math.PI);
+		expect(helpers.math.toDegrees(Math.PI)).toBe(180);
+		expect(helpers.math.toDegrees(Math.PI * 3 / 2)).toBe(270);
+	});
+
+	it('should get the correct number of decimal places', function() {
+		expect(helpers.math.decimalPlaces(100)).toBe(0);
+		expect(helpers.math.decimalPlaces(1)).toBe(0);
+		expect(helpers.math.decimalPlaces(0)).toBe(0);
+		expect(helpers.math.decimalPlaces(0.01)).toBe(2);
+		expect(helpers.math.decimalPlaces(-0.01)).toBe(2);
+		expect(helpers.math.decimalPlaces('1')).toBe(undefined);
+		expect(helpers.math.decimalPlaces('')).toBe(undefined);
+		expect(helpers.math.decimalPlaces(undefined)).toBe(undefined);
+	});
+
+	it('should get an angle from a point', function() {
+		var center = {
+			x: 0,
+			y: 0
+		};
+
+		expect(helpers.math.getAngleFromPoint(center, {
+			x: 0,
+			y: 10
+		})).toEqual({
+			angle: Math.PI / 2,
+			distance: 10,
+		});
+
+		expect(helpers.math.getAngleFromPoint(center, {
+			x: Math.sqrt(2),
+			y: Math.sqrt(2)
+		})).toEqual({
+			angle: Math.PI / 4,
+			distance: 2
+		});
+
+		expect(helpers.math.getAngleFromPoint(center, {
+			x: -1.0 * Math.sqrt(2),
+			y: -1.0 * Math.sqrt(2)
+		})).toEqual({
+			angle: Math.PI * 1.25,
+			distance: 2
+		});
+	});
+
+	it('should spline curves', function() {
+		expect(helpers.math.splineCurve({
+			x: 0,
+			y: 0
+		}, {
+			x: 1,
+			y: 1
+		}, {
+			x: 2,
+			y: 0
+		}, 0)).toEqual({
+			previous: {
+				x: 1,
+				y: 1,
+			},
+			next: {
+				x: 1,
+				y: 1,
+			}
+		});
+
+		expect(helpers.math.splineCurve({
+			x: 0,
+			y: 0
+		}, {
+			x: 1,
+			y: 1
+		}, {
+			x: 2,
+			y: 0
+		}, 1)).toEqual({
+			previous: {
+				x: 0,
+				y: 1,
+			},
+			next: {
+				x: 2,
+				y: 1,
+			}
+		});
+	});
+
+	it('should spline curves with monotone cubic interpolation', function() {
+		var dataPoints = [
+			{_model: {x: 0, y: 0, skip: false}},
+			{_model: {x: 3, y: 6, skip: false}},
+			{_model: {x: 9, y: 6, skip: false}},
+			{_model: {x: 12, y: 60, skip: false}},
+			{_model: {x: 15, y: 60, skip: false}},
+			{_model: {x: 18, y: 120, skip: false}},
+			{_model: {x: null, y: null, skip: true}},
+			{_model: {x: 21, y: 180, skip: false}},
+			{_model: {x: 24, y: 120, skip: false}},
+			{_model: {x: 27, y: 125, skip: false}},
+			{_model: {x: 30, y: 105, skip: false}},
+			{_model: {x: 33, y: 110, skip: false}},
+			{_model: {x: 33, y: 110, skip: false}},
+			{_model: {x: 36, y: 170, skip: false}}
+		];
+		helpers.math.splineCurveMonotone(dataPoints);
+		expect(dataPoints).toEqual([{
+			_model: {
+				x: 0,
+				y: 0,
+				skip: false,
+				controlPointNextX: 1,
+				controlPointNextY: 2
+			}
+		},
+		{
+			_model: {
+				x: 3,
+				y: 6,
+				skip: false,
+				controlPointPreviousX: 2,
+				controlPointPreviousY: 6,
+				controlPointNextX: 5,
+				controlPointNextY: 6
+			}
+		},
+		{
+			_model: {
+				x: 9,
+				y: 6,
+				skip: false,
+				controlPointPreviousX: 7,
+				controlPointPreviousY: 6,
+				controlPointNextX: 10,
+				controlPointNextY: 6
+			}
+		},
+		{
+			_model: {
+				x: 12,
+				y: 60,
+				skip: false,
+				controlPointPreviousX: 11,
+				controlPointPreviousY: 60,
+				controlPointNextX: 13,
+				controlPointNextY: 60
+			}
+		},
+		{
+			_model: {
+				x: 15,
+				y: 60,
+				skip: false,
+				controlPointPreviousX: 14,
+				controlPointPreviousY: 60,
+				controlPointNextX: 16,
+				controlPointNextY: 60
+			}
+		},
+		{
+			_model: {
+				x: 18,
+				y: 120,
+				skip: false,
+				controlPointPreviousX: 17,
+				controlPointPreviousY: 100
+			}
+		},
+		{
+			_model: {
+				x: null,
+				y: null,
+				skip: true
+			}
+		},
+		{
+			_model: {
+				x: 21,
+				y: 180,
+				skip: false,
+				controlPointNextX: 22,
+				controlPointNextY: 160
+			}
+		},
+		{
+			_model: {
+				x: 24,
+				y: 120,
+				skip: false,
+				controlPointPreviousX: 23,
+				controlPointPreviousY: 120,
+				controlPointNextX: 25,
+				controlPointNextY: 120
+			}
+		},
+		{
+			_model: {
+				x: 27,
+				y: 125,
+				skip: false,
+				controlPointPreviousX: 26,
+				controlPointPreviousY: 125,
+				controlPointNextX: 28,
+				controlPointNextY: 125
+			}
+		},
+		{
+			_model: {
+				x: 30,
+				y: 105,
+				skip: false,
+				controlPointPreviousX: 29,
+				controlPointPreviousY: 105,
+				controlPointNextX: 31,
+				controlPointNextY: 105
+			}
+		},
+		{
+			_model: {
+				x: 33,
+				y: 110,
+				skip: false,
+				controlPointPreviousX: 32,
+				controlPointPreviousY: 110,
+				controlPointNextX: 33,
+				controlPointNextY: 110
+			}
+		},
+		{
+			_model: {
+				x: 33,
+				y: 110,
+				skip: false,
+				controlPointPreviousX: 33,
+				controlPointPreviousY: 110,
+				controlPointNextX: 34,
+				controlPointNextY: 110
+			}
+		},
+		{
+			_model: {
+				x: 36,
+				y: 170,
+				skip: false,
+				controlPointPreviousX: 35,
+				controlPointPreviousY: 150
+			}
+		}]);
+	});
+
+	it('should get the next or previous item in an array', function() {
+		var testData = [0, 1, 2];
+
+		expect(helpers.math.nextItem(testData, 0, false)).toEqual(1);
+		expect(helpers.math.nextItem(testData, 2, false)).toEqual(2);
+		expect(helpers.math.nextItem(testData, 2, true)).toEqual(0);
+		expect(helpers.math.nextItem(testData, 1, true)).toEqual(2);
+		expect(helpers.math.nextItem(testData, -1, false)).toEqual(0);
+
+		expect(helpers.math.previousItem(testData, 0, false)).toEqual(0);
+		expect(helpers.math.previousItem(testData, 0, true)).toEqual(2);
+		expect(helpers.math.previousItem(testData, 2, false)).toEqual(1);
+		expect(helpers.math.previousItem(testData, 1, true)).toEqual(0);
+	});
+});

From 2aef51bb9b88186612030eea2fa055b7758d362e Mon Sep 17 00:00:00 2001
From: Evgeniy <eeiaao@gmail.com>
Date: Sun, 16 Dec 2018 19:21:54 +0300
Subject: [PATCH 5/6] Dispatch dom related methods to helpers.dom

---
 src/core/core.controller.js      |   8 +-
 src/core/core.helpers.js         | 167 --------------------
 src/core/core.interaction.js     |   2 +-
 src/helpers/helpers.dom.js       | 176 +++++++++++++++++++++
 src/helpers/index.js             |   1 +
 src/platforms/platform.dom.js    |   4 +-
 test/specs/core.helpers.tests.js | 251 ------------------------------
 test/specs/helpers.dom.tests.js  | 259 +++++++++++++++++++++++++++++++
 8 files changed, 443 insertions(+), 425 deletions(-)
 create mode 100644 src/helpers/helpers.dom.js
 create mode 100644 test/specs/helpers.dom.tests.js

diff --git a/src/core/core.controller.js b/src/core/core.controller.js
index a4f7e3e55c0..a5eaa5c03b1 100644
--- a/src/core/core.controller.js
+++ b/src/core/core.controller.js
@@ -139,7 +139,7 @@ module.exports = function(Chart) {
 			// Before init plugin notification
 			plugins.notify(me, 'beforeInit');
 
-			helpers.retinaScale(me, me.options.devicePixelRatio);
+			helpers.dom.retinaScale(me, me.options.devicePixelRatio);
 
 			me.bindEvents();
 
@@ -180,8 +180,8 @@ module.exports = function(Chart) {
 			// the canvas display style uses the same integer values to avoid blurring effect.
 
 			// Set to 0 instead of canvas.size because the size defaults to 300x150 if the element is collapsed
-			var newWidth = Math.max(0, Math.floor(helpers.getMaximumWidth(canvas)));
-			var newHeight = Math.max(0, Math.floor(aspectRatio ? newWidth / aspectRatio : helpers.getMaximumHeight(canvas)));
+			var newWidth = Math.max(0, Math.floor(helpers.dom.getMaximumWidth(canvas)));
+			var newHeight = Math.max(0, Math.floor(aspectRatio ? newWidth / aspectRatio : helpers.dom.getMaximumHeight(canvas)));
 
 			if (me.width === newWidth && me.height === newHeight) {
 				return;
@@ -192,7 +192,7 @@ module.exports = function(Chart) {
 			canvas.style.width = newWidth + 'px';
 			canvas.style.height = newHeight + 'px';
 
-			helpers.retinaScale(me, options.devicePixelRatio);
+			helpers.dom.retinaScale(me, options.devicePixelRatio);
 
 			if (!silent) {
 				// Notify any plugins about the resize
diff --git a/src/core/core.helpers.js b/src/core/core.helpers.js
index fea57de4166..7699167e89d 100644
--- a/src/core/core.helpers.js
+++ b/src/core/core.helpers.js
@@ -114,171 +114,4 @@ module.exports = function() {
 			}
 		}
 	};
-	// -- DOM methods
-	helpers.getRelativePosition = function(evt, chart) {
-		var mouseX, mouseY;
-		var e = evt.originalEvent || evt;
-		var canvas = evt.target || evt.srcElement;
-		var boundingRect = canvas.getBoundingClientRect();
-
-		var touches = e.touches;
-		if (touches && touches.length > 0) {
-			mouseX = touches[0].clientX;
-			mouseY = touches[0].clientY;
-
-		} else {
-			mouseX = e.clientX;
-			mouseY = e.clientY;
-		}
-
-		// Scale mouse coordinates into canvas coordinates
-		// by following the pattern laid out by 'jerryj' in the comments of
-		// https://www.html5canvastutorials.com/advanced/html5-canvas-mouse-coordinates/
-		var paddingLeft = parseFloat(helpers.getStyle(canvas, 'padding-left'));
-		var paddingTop = parseFloat(helpers.getStyle(canvas, 'padding-top'));
-		var paddingRight = parseFloat(helpers.getStyle(canvas, 'padding-right'));
-		var paddingBottom = parseFloat(helpers.getStyle(canvas, 'padding-bottom'));
-		var width = boundingRect.right - boundingRect.left - paddingLeft - paddingRight;
-		var height = boundingRect.bottom - boundingRect.top - paddingTop - paddingBottom;
-
-		// We divide by the current device pixel ratio, because the canvas is scaled up by that amount in each direction. However
-		// the backend model is in unscaled coordinates. Since we are going to deal with our model coordinates, we go back here
-		mouseX = Math.round((mouseX - boundingRect.left - paddingLeft) / (width) * canvas.width / chart.currentDevicePixelRatio);
-		mouseY = Math.round((mouseY - boundingRect.top - paddingTop) / (height) * canvas.height / chart.currentDevicePixelRatio);
-
-		return {
-			x: mouseX,
-			y: mouseY
-		};
-
-	};
-
-	// Private helper function to convert max-width/max-height values that may be percentages into a number
-	function parseMaxStyle(styleValue, node, parentProperty) {
-		var valueInPixels;
-		if (typeof styleValue === 'string') {
-			valueInPixels = parseInt(styleValue, 10);
-
-			if (styleValue.indexOf('%') !== -1) {
-				// percentage * size in dimension
-				valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];
-			}
-		} else {
-			valueInPixels = styleValue;
-		}
-
-		return valueInPixels;
-	}
-
-	/**
-	 * Returns if the given value contains an effective constraint.
-	 * @private
-	 */
-	function isConstrainedValue(value) {
-		return value !== undefined && value !== null && value !== 'none';
-	}
-
-	// Private helper to get a constraint dimension
-	// @param domNode : the node to check the constraint on
-	// @param maxStyle : the style that defines the maximum for the direction we are using (maxWidth / maxHeight)
-	// @param percentageProperty : property of parent to use when calculating width as a percentage
-	// @see https://www.nathanaeljones.com/blog/2013/reading-max-width-cross-browser
-	function getConstraintDimension(domNode, maxStyle, percentageProperty) {
-		var view = document.defaultView;
-		var parentNode = helpers._getParentNode(domNode);
-		var constrainedNode = view.getComputedStyle(domNode)[maxStyle];
-		var constrainedContainer = view.getComputedStyle(parentNode)[maxStyle];
-		var hasCNode = isConstrainedValue(constrainedNode);
-		var hasCContainer = isConstrainedValue(constrainedContainer);
-		var infinity = Number.POSITIVE_INFINITY;
-
-		if (hasCNode || hasCContainer) {
-			return Math.min(
-				hasCNode ? parseMaxStyle(constrainedNode, domNode, percentageProperty) : infinity,
-				hasCContainer ? parseMaxStyle(constrainedContainer, parentNode, percentageProperty) : infinity);
-		}
-
-		return 'none';
-	}
-	// returns Number or undefined if no constraint
-	helpers.getConstraintWidth = function(domNode) {
-		return getConstraintDimension(domNode, 'max-width', 'clientWidth');
-	};
-	// returns Number or undefined if no constraint
-	helpers.getConstraintHeight = function(domNode) {
-		return getConstraintDimension(domNode, 'max-height', 'clientHeight');
-	};
-	/**
-	 * @private
- 	 */
-	helpers._calculatePadding = function(container, padding, parentDimension) {
-		padding = helpers.getStyle(container, padding);
-
-		return padding.indexOf('%') > -1 ? parentDimension * parseInt(padding, 10) / 100 : parseInt(padding, 10);
-	};
-	/**
-	 * @private
-	 */
-	helpers._getParentNode = function(domNode) {
-		var parent = domNode.parentNode;
-		if (parent && parent.toString() === '[object ShadowRoot]') {
-			parent = parent.host;
-		}
-		return parent;
-	};
-	helpers.getMaximumWidth = function(domNode) {
-		var container = helpers._getParentNode(domNode);
-		if (!container) {
-			return domNode.clientWidth;
-		}
-
-		var clientWidth = container.clientWidth;
-		var paddingLeft = helpers._calculatePadding(container, 'padding-left', clientWidth);
-		var paddingRight = helpers._calculatePadding(container, 'padding-right', clientWidth);
-
-		var w = clientWidth - paddingLeft - paddingRight;
-		var cw = helpers.getConstraintWidth(domNode);
-		return isNaN(cw) ? w : Math.min(w, cw);
-	};
-	helpers.getMaximumHeight = function(domNode) {
-		var container = helpers._getParentNode(domNode);
-		if (!container) {
-			return domNode.clientHeight;
-		}
-
-		var clientHeight = container.clientHeight;
-		var paddingTop = helpers._calculatePadding(container, 'padding-top', clientHeight);
-		var paddingBottom = helpers._calculatePadding(container, 'padding-bottom', clientHeight);
-
-		var h = clientHeight - paddingTop - paddingBottom;
-		var ch = helpers.getConstraintHeight(domNode);
-		return isNaN(ch) ? h : Math.min(h, ch);
-	};
-	helpers.getStyle = function(el, property) {
-		return el.currentStyle ?
-			el.currentStyle[property] :
-			document.defaultView.getComputedStyle(el, null).getPropertyValue(property);
-	};
-	helpers.retinaScale = function(chart, forceRatio) {
-		var pixelRatio = chart.currentDevicePixelRatio = forceRatio || (typeof window !== 'undefined' && window.devicePixelRatio) || 1;
-		if (pixelRatio === 1) {
-			return;
-		}
-
-		var canvas = chart.canvas;
-		var height = chart.height;
-		var width = chart.width;
-
-		canvas.height = height * pixelRatio;
-		canvas.width = width * pixelRatio;
-		chart.ctx.scale(pixelRatio, pixelRatio);
-
-		// If no style has been set on the canvas, the render size is used as display size,
-		// making the chart visually bigger, so let's enforce it to the "correct" values.
-		// See https://github.com/chartjs/Chart.js/issues/3575
-		if (!canvas.style.height && !canvas.style.width) {
-			canvas.style.height = height + 'px';
-			canvas.style.width = width + 'px';
-		}
-	};
 };
diff --git a/src/core/core.interaction.js b/src/core/core.interaction.js
index 9b99e53bb1b..a7daecea3da 100644
--- a/src/core/core.interaction.js
+++ b/src/core/core.interaction.js
@@ -16,7 +16,7 @@ function getRelativePosition(e, chart) {
 		};
 	}
 
-	return helpers.getRelativePosition(e, chart);
+	return helpers.dom.getRelativePosition(e, chart);
 }
 
 /**
diff --git a/src/helpers/helpers.dom.js b/src/helpers/helpers.dom.js
new file mode 100644
index 00000000000..2fb9ba8521e
--- /dev/null
+++ b/src/helpers/helpers.dom.js
@@ -0,0 +1,176 @@
+'use strict';
+
+/**
+ * @namespace Chart.helpers.dom
+ */
+var helpersDom = {
+	getRelativePosition: function(evt, chart) {
+		var mouseX, mouseY;
+		var e = evt.originalEvent || evt;
+		var canvas = evt.target || evt.srcElement;
+		var boundingRect = canvas.getBoundingClientRect();
+
+		var touches = e.touches;
+		if (touches && touches.length > 0) {
+			mouseX = touches[0].clientX;
+			mouseY = touches[0].clientY;
+
+		} else {
+			mouseX = e.clientX;
+			mouseY = e.clientY;
+		}
+
+		// Scale mouse coordinates into canvas coordinates
+		// by following the pattern laid out by 'jerryj' in the comments of
+		// http://www.html5canvastutorials.com/advanced/html5-canvas-mouse-coordinates/
+		var paddingLeft = parseFloat(helpersDom.getStyle(canvas, 'padding-left'));
+		var paddingTop = parseFloat(helpersDom.getStyle(canvas, 'padding-top'));
+		var paddingRight = parseFloat(helpersDom.getStyle(canvas, 'padding-right'));
+		var paddingBottom = parseFloat(helpersDom.getStyle(canvas, 'padding-bottom'));
+		var width = boundingRect.right - boundingRect.left - paddingLeft - paddingRight;
+		var height = boundingRect.bottom - boundingRect.top - paddingTop - paddingBottom;
+
+		// We divide by the current device pixel ratio, because the canvas is scaled up by that amount in each direction. However
+		// the backend model is in unscaled coordinates. Since we are going to deal with our model coordinates, we go back here
+		mouseX = Math.round((mouseX - boundingRect.left - paddingLeft) / (width) * canvas.width / chart.currentDevicePixelRatio);
+		mouseY = Math.round((mouseY - boundingRect.top - paddingTop) / (height) * canvas.height / chart.currentDevicePixelRatio);
+
+		return {
+			x: mouseX,
+			y: mouseY
+		};
+
+	},
+
+	// Private helper function to convert max-width/max-height values that may be percentages into a number
+	_parseMaxStyle: function(styleValue, node, parentProperty) {
+		var valueInPixels;
+		if (typeof styleValue === 'string') {
+			valueInPixels = parseInt(styleValue, 10);
+
+			if (styleValue.indexOf('%') !== -1) {
+				// percentage * size in dimension
+				valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];
+			}
+		} else {
+			valueInPixels = styleValue;
+		}
+
+		return valueInPixels;
+	},
+
+	/**
+	 * Returns if the given value contains an effective constraint.
+	 * @private
+	 */
+	_isConstrainedValue: function(value) {
+		return value !== undefined && value !== null && value !== 'none';
+	},
+
+	// Private helper to get a constraint dimension
+	// @param domNode : the node to check the constraint on
+	// @param maxStyle : the style that defines the maximum for the direction we are using (maxWidth / maxHeight)
+	// @param percentageProperty : property of parent to use when calculating width as a percentage
+	// @see http://www.nathanaeljones.com/blog/2013/reading-max-width-cross-browser
+	_getConstraintDimension: function(domNode, maxStyle, percentageProperty) {
+		var view = document.defaultView;
+		var parentNode = helpersDom._getParentNode(domNode);
+		var constrainedNode = view.getComputedStyle(domNode)[maxStyle];
+		var constrainedContainer = view.getComputedStyle(parentNode)[maxStyle];
+		var hasCNode = helpersDom._isConstrainedValue(constrainedNode);
+		var hasCContainer = helpersDom._isConstrainedValue(constrainedContainer);
+		var infinity = Number.POSITIVE_INFINITY;
+
+		if (hasCNode || hasCContainer) {
+			return Math.min(
+				hasCNode ? helpersDom._parseMaxStyle(constrainedNode, domNode, percentageProperty) : infinity,
+				hasCContainer ? helpersDom._parseMaxStyle(constrainedContainer, parentNode, percentageProperty) : infinity);
+		}
+
+		return 'none';
+	},
+	// returns Number or undefined if no constraint
+	getConstraintWidth: function(domNode) {
+		return helpersDom._getConstraintDimension(domNode, 'max-width', 'clientWidth');
+	},
+	// returns Number or undefined if no constraint
+	getConstraintHeight: function(domNode) {
+		return helpersDom._getConstraintDimension(domNode, 'max-height', 'clientHeight');
+	},
+	/**
+	 * @private
+	 */
+	_calculatePadding: function(container, padding, parentDimension) {
+		padding = helpersDom.getStyle(container, padding);
+
+		return padding.indexOf('%') > -1 ? parentDimension * parseInt(padding, 10) / 100 : parseInt(padding, 10);
+	},
+	/**
+	 * @private
+	 */
+	_getParentNode: function(domNode) {
+		var parent = domNode.parentNode;
+		if (parent && parent.toString() === '[object ShadowRoot]') {
+			parent = parent.host;
+		}
+		return parent;
+	},
+	getMaximumWidth: function(domNode) {
+		var container = helpersDom._getParentNode(domNode);
+		if (!container) {
+			return domNode.clientWidth;
+		}
+
+		var clientWidth = container.clientWidth;
+		var paddingLeft = helpersDom._calculatePadding(container, 'padding-left', clientWidth);
+		var paddingRight = helpersDom._calculatePadding(container, 'padding-right', clientWidth);
+
+		var w = clientWidth - paddingLeft - paddingRight;
+		var cw = helpersDom.getConstraintWidth(domNode);
+		return isNaN(cw) ? w : Math.min(w, cw);
+	},
+	getMaximumHeight: function(domNode) {
+		var container = helpersDom._getParentNode(domNode);
+		if (!container) {
+			return domNode.clientHeight;
+		}
+
+		var clientHeight = container.clientHeight;
+		var paddingTop = helpersDom._calculatePadding(container, 'padding-top', clientHeight);
+		var paddingBottom = helpersDom._calculatePadding(container, 'padding-bottom', clientHeight);
+
+		var h = clientHeight - paddingTop - paddingBottom;
+		var ch = helpersDom.getConstraintHeight(domNode);
+		return isNaN(ch) ? h : Math.min(h, ch);
+	},
+	getStyle: function(el, property) {
+		return el.currentStyle ?
+			el.currentStyle[property] :
+			document.defaultView.getComputedStyle(el, null).getPropertyValue(property);
+	},
+	retinaScale: function(chart, forceRatio) {
+		var pixelRatio = chart.currentDevicePixelRatio = forceRatio || (typeof window !== 'undefined' && window.devicePixelRatio) || 1;
+		if (pixelRatio === 1) {
+			return;
+		}
+
+		var canvas = chart.canvas;
+		var height = chart.height;
+		var width = chart.width;
+
+		canvas.height = height * pixelRatio;
+		canvas.width = width * pixelRatio;
+		chart.ctx.scale(pixelRatio, pixelRatio);
+
+		// If no style has been set on the canvas, the render size is used as display size,
+		// making the chart visually bigger, so let's enforce it to the "correct" values.
+		// See https://github.com/chartjs/Chart.js/issues/3575
+		if (!canvas.style.height && !canvas.style.width) {
+			canvas.style.height = height + 'px';
+			canvas.style.width = width + 'px';
+		}
+	}
+};
+
+
+module.exports = helpersDom;
diff --git a/src/helpers/index.js b/src/helpers/index.js
index ef510076090..02a67bdb6c2 100644
--- a/src/helpers/index.js
+++ b/src/helpers/index.js
@@ -5,3 +5,4 @@ module.exports.easing = require('./helpers.easing');
 module.exports.canvas = require('./helpers.canvas');
 module.exports.options = require('./helpers.options');
 module.exports.math = require('./helpers.math');
+module.exports.dom = require('./helpers.dom');
diff --git a/src/platforms/platform.dom.js b/src/platforms/platform.dom.js
index f0cfbff4170..d1307c4d4ff 100644
--- a/src/platforms/platform.dom.js
+++ b/src/platforms/platform.dom.js
@@ -39,7 +39,7 @@ var EVENT_TYPES = {
  * @returns {Number} Size in pixels or undefined if unknown.
  */
 function readUsedSize(element, property) {
-	var value = helpers.getStyle(element, property);
+	var value = helpers.dom.getStyle(element, property);
 	var matches = value && value.match(/^(\d+)(\.\d+)?px$/);
 	return matches ? Number(matches[1]) : undefined;
 }
@@ -144,7 +144,7 @@ function createEvent(type, chart, x, y, nativeEvent) {
 
 function fromNativeEvent(event, chart) {
 	var type = EVENT_TYPES[event.type] || event.type;
-	var pos = helpers.getRelativePosition(event, chart);
+	var pos = helpers.dom.getRelativePosition(event, chart);
 	return createEvent(type, chart, pos.x, pos.y, event);
 }
 
diff --git a/test/specs/core.helpers.tests.js b/test/specs/core.helpers.tests.js
index 932e4c39ad1..e1b5d29135c 100644
--- a/test/specs/core.helpers.tests.js
+++ b/test/specs/core.helpers.tests.js
@@ -193,255 +193,4 @@ describe('Core helper tests', function() {
 		expect(helpers.uid()).toBe(uid + 2);
 		expect(helpers.uid()).toBe(uid + 3);
 	});
-
-	it ('should get the maximum width and height for a node', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create the div we want to get the max size for
-		var innerDiv = document.createElement('div');
-		div.appendChild(innerDiv);
-
-		expect(helpers.getMaximumWidth(innerDiv)).toBe(200);
-		expect(helpers.getMaximumHeight(innerDiv)).toBe(300);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum width and height for a node in a ShadowRoot', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		if (!div.attachShadow) {
-			// Shadow DOM is not natively supported
-			return;
-		}
-
-		var shadow = div.attachShadow({mode: 'closed'});
-
-		// Create the div we want to get the max size for
-		var innerDiv = document.createElement('div');
-		shadow.appendChild(innerDiv);
-
-		expect(helpers.getMaximumWidth(innerDiv)).toBe(200);
-		expect(helpers.getMaximumHeight(innerDiv)).toBe(300);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum width of a node that has a max-width style', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create the div we want to get the max size for and set a max-width style
-		var innerDiv = document.createElement('div');
-		innerDiv.style.maxWidth = '150px';
-		div.appendChild(innerDiv);
-
-		expect(helpers.getMaximumWidth(innerDiv)).toBe(150);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum height of a node that has a max-height style', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create the div we want to get the max size for and set a max-height style
-		var innerDiv = document.createElement('div');
-		innerDiv.style.maxHeight = '150px';
-		div.appendChild(innerDiv);
-
-		expect(helpers.getMaximumHeight(innerDiv)).toBe(150);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum width of a node when the parent has a max-width style', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create an inner wrapper around our div we want to size and give that a max-width style
-		var parentDiv = document.createElement('div');
-		parentDiv.style.maxWidth = '150px';
-		div.appendChild(parentDiv);
-
-		// Create the div we want to get the max size for
-		var innerDiv = document.createElement('div');
-		parentDiv.appendChild(innerDiv);
-
-		expect(helpers.getMaximumWidth(innerDiv)).toBe(150);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum height of a node when the parent has a max-height style', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create an inner wrapper around our div we want to size and give that a max-height style
-		var parentDiv = document.createElement('div');
-		parentDiv.style.maxHeight = '150px';
-		div.appendChild(parentDiv);
-
-		// Create the div we want to get the max size for
-		var innerDiv = document.createElement('div');
-		innerDiv.style.height = '300px'; // make it large
-		parentDiv.appendChild(innerDiv);
-
-		expect(helpers.getMaximumHeight(innerDiv)).toBe(150);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum width of a node that has a percentage max-width style', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create the div we want to get the max size for and set a max-width style
-		var innerDiv = document.createElement('div');
-		innerDiv.style.maxWidth = '50%';
-		div.appendChild(innerDiv);
-
-		expect(helpers.getMaximumWidth(innerDiv)).toBe(100);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum height of a node that has a percentage max-height style', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create the div we want to get the max size for and set a max-height style
-		var innerDiv = document.createElement('div');
-		innerDiv.style.maxHeight = '50%';
-		div.appendChild(innerDiv);
-
-		expect(helpers.getMaximumHeight(innerDiv)).toBe(150);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum width of a node when the parent has a percentage max-width style', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create an inner wrapper around our div we want to size and give that a max-width style
-		var parentDiv = document.createElement('div');
-		parentDiv.style.maxWidth = '50%';
-		div.appendChild(parentDiv);
-
-		// Create the div we want to get the max size for
-		var innerDiv = document.createElement('div');
-		parentDiv.appendChild(innerDiv);
-
-		expect(helpers.getMaximumWidth(innerDiv)).toBe(100);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should get the maximum height of a node when the parent has a percentage max-height style', function() {
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '200px';
-		div.style.height = '300px';
-
-		document.body.appendChild(div);
-
-		// Create an inner wrapper around our div we want to size and give that a max-height style
-		var parentDiv = document.createElement('div');
-		parentDiv.style.maxHeight = '50%';
-		div.appendChild(parentDiv);
-
-		var innerDiv = document.createElement('div');
-		innerDiv.style.height = '300px'; // make it large
-		parentDiv.appendChild(innerDiv);
-
-		expect(helpers.getMaximumHeight(innerDiv)).toBe(150);
-
-		document.body.removeChild(div);
-	});
-
-	it ('should leave styled height and width on canvas if explicitly set', function() {
-		var chart = window.acquireChart({}, {
-			canvas: {
-				height: 200,
-				width: 200,
-				style: 'height: 400px; width: 400px;'
-			}
-		});
-
-		helpers.retinaScale(chart, true);
-
-		var canvas = chart.canvas;
-
-		expect(canvas.style.height).toBe('400px');
-		expect(canvas.style.width).toBe('400px');
-	});
-
-	it ('Should get padding of parent as number (pixels) when defined as percent (returns incorrectly in IE11)', function() {
-
-		// Create div with fixed size as a test bed
-		var div = document.createElement('div');
-		div.style.width = '300px';
-		div.style.height = '300px';
-		document.body.appendChild(div);
-
-		// Inner DIV to have 5% padding of parent
-		var innerDiv = document.createElement('div');
-
-		div.appendChild(innerDiv);
-
-		var canvas = document.createElement('canvas');
-		innerDiv.appendChild(canvas);
-
-		// No padding
-		expect(helpers.getMaximumWidth(canvas)).toBe(300);
-
-		// test with percentage
-		innerDiv.style.padding = '5%';
-		expect(helpers.getMaximumWidth(canvas)).toBe(270);
-
-		// test with pixels
-		innerDiv.style.padding = '10px';
-		expect(helpers.getMaximumWidth(canvas)).toBe(280);
-
-		document.body.removeChild(div);
-	});
 });
diff --git a/test/specs/helpers.dom.tests.js b/test/specs/helpers.dom.tests.js
new file mode 100644
index 00000000000..d6b9819b6fc
--- /dev/null
+++ b/test/specs/helpers.dom.tests.js
@@ -0,0 +1,259 @@
+describe('Math helper tests', function() {
+
+	var helpers;
+
+	beforeAll(function() {
+		helpers = window.Chart.helpers;
+	});
+
+	it ('should get the maximum width and height for a node', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create the div we want to get the max size for
+		var innerDiv = document.createElement('div');
+		div.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumWidth(innerDiv)).toBe(200);
+		expect(helpers.dom.getMaximumHeight(innerDiv)).toBe(300);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum width and height for a node in a ShadowRoot', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		if (!div.attachShadow) {
+			// Shadow DOM is not natively supported
+			return;
+		}
+
+		var shadow = div.attachShadow({mode: 'closed'});
+
+		// Create the div we want to get the max size for
+		var innerDiv = document.createElement('div');
+		shadow.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumWidth(innerDiv)).toBe(200);
+		expect(helpers.dom.getMaximumHeight(innerDiv)).toBe(300);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum width of a node that has a max-width style', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create the div we want to get the max size for and set a max-width style
+		var innerDiv = document.createElement('div');
+		innerDiv.style.maxWidth = '150px';
+		div.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumWidth(innerDiv)).toBe(150);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum height of a node that has a max-height style', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create the div we want to get the max size for and set a max-height style
+		var innerDiv = document.createElement('div');
+		innerDiv.style.maxHeight = '150px';
+		div.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumHeight(innerDiv)).toBe(150);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum width of a node when the parent has a max-width style', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create an inner wrapper around our div we want to size and give that a max-width style
+		var parentDiv = document.createElement('div');
+		parentDiv.style.maxWidth = '150px';
+		div.appendChild(parentDiv);
+
+		// Create the div we want to get the max size for
+		var innerDiv = document.createElement('div');
+		parentDiv.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumWidth(innerDiv)).toBe(150);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum height of a node when the parent has a max-height style', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create an inner wrapper around our div we want to size and give that a max-height style
+		var parentDiv = document.createElement('div');
+		parentDiv.style.maxHeight = '150px';
+		div.appendChild(parentDiv);
+
+		// Create the div we want to get the max size for
+		var innerDiv = document.createElement('div');
+		innerDiv.style.height = '300px'; // make it large
+		parentDiv.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumHeight(innerDiv)).toBe(150);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum width of a node that has a percentage max-width style', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create the div we want to get the max size for and set a max-width style
+		var innerDiv = document.createElement('div');
+		innerDiv.style.maxWidth = '50%';
+		div.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumWidth(innerDiv)).toBe(100);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum height of a node that has a percentage max-height style', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create the div we want to get the max size for and set a max-height style
+		var innerDiv = document.createElement('div');
+		innerDiv.style.maxHeight = '50%';
+		div.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumHeight(innerDiv)).toBe(150);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum width of a node when the parent has a percentage max-width style', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create an inner wrapper around our div we want to size and give that a max-width style
+		var parentDiv = document.createElement('div');
+		parentDiv.style.maxWidth = '50%';
+		div.appendChild(parentDiv);
+
+		// Create the div we want to get the max size for
+		var innerDiv = document.createElement('div');
+		parentDiv.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumWidth(innerDiv)).toBe(100);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should get the maximum height of a node when the parent has a percentage max-height style', function() {
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '200px';
+		div.style.height = '300px';
+
+		document.body.appendChild(div);
+
+		// Create an inner wrapper around our div we want to size and give that a max-height style
+		var parentDiv = document.createElement('div');
+		parentDiv.style.maxHeight = '50%';
+		div.appendChild(parentDiv);
+
+		var innerDiv = document.createElement('div');
+		innerDiv.style.height = '300px'; // make it large
+		parentDiv.appendChild(innerDiv);
+
+		expect(helpers.dom.getMaximumHeight(innerDiv)).toBe(150);
+
+		document.body.removeChild(div);
+	});
+
+	it ('should leave styled height and width on canvas if explicitly set', function() {
+		var chart = window.acquireChart({}, {
+			canvas: {
+				height: 200,
+				width: 200,
+				style: 'height: 400px; width: 400px;'
+			}
+		});
+
+		helpers.dom.retinaScale(chart, true);
+
+		var canvas = chart.canvas;
+
+		expect(canvas.style.height).toBe('400px');
+		expect(canvas.style.width).toBe('400px');
+	});
+
+	it ('Should get padding of parent as number (pixels) when defined as percent (returns incorrectly in IE11)', function() {
+
+		// Create div with fixed size as a test bed
+		var div = document.createElement('div');
+		div.style.width = '300px';
+		div.style.height = '300px';
+		document.body.appendChild(div);
+
+		// Inner DIV to have 5% padding of parent
+		var innerDiv = document.createElement('div');
+
+		div.appendChild(innerDiv);
+
+		var canvas = document.createElement('canvas');
+		innerDiv.appendChild(canvas);
+
+		// No padding
+		expect(helpers.dom.getMaximumWidth(canvas)).toBe(300);
+
+		// test with percentage
+		innerDiv.style.padding = '5%';
+		expect(helpers.dom.getMaximumWidth(canvas)).toBe(270);
+
+		// test with pixels
+		innerDiv.style.padding = '10px';
+		expect(helpers.dom.getMaximumWidth(canvas)).toBe(280);
+
+		document.body.removeChild(div);
+	});
+});

From c594c9801e01cedd5c6d32dac4ed630c28866793 Mon Sep 17 00:00:00 2001
From: Evgeniy <eeiaao@gmail.com>
Date: Sun, 16 Dec 2018 19:51:31 +0300
Subject: [PATCH 6/6] Dispatch basic utility methods to helpers.utility

---
 src/chart.js                                  |   3 -
 src/core/core.animations.js                   |   2 +-
 src/core/core.controller.js                   |   4 +-
 src/core/core.layouts.js                      |   6 +-
 .../helpers.utility.js}                       |  41 ++--
 src/helpers/index.js                          |   1 +
 test/specs/core.helpers.tests.js              | 180 -----------------
 test/specs/helpers.utility.tests.js           | 188 ++++++++++++++++++
 8 files changed, 216 insertions(+), 209 deletions(-)
 rename src/{core/core.helpers.js => helpers/helpers.utility.js} (82%)
 create mode 100644 test/specs/helpers.utility.tests.js

diff --git a/src/chart.js b/src/chart.js
index b60129f2cf5..e9d966e583d 100644
--- a/src/chart.js
+++ b/src/chart.js
@@ -5,9 +5,6 @@ var Chart = require('./core/core')();
 
 Chart.helpers = require('./helpers/index');
 
-// @todo dispatch these helpers into appropriated helpers/helpers.* file and write unit tests!
-require('./core/core.helpers')(Chart);
-
 Chart.Animation = require('./core/core.animation');
 Chart.animationService = require('./core/core.animations');
 Chart.controllers = require('./controllers/index');
diff --git a/src/core/core.animations.js b/src/core/core.animations.js
index cec26496fc4..9de1fab8026 100644
--- a/src/core/core.animations.js
+++ b/src/core/core.animations.js
@@ -51,7 +51,7 @@ module.exports = {
 	},
 
 	cancelAnimation: function(chart) {
-		var index = helpers.findIndex(this.animations, function(animation) {
+		var index = helpers.utility.findIndex(this.animations, function(animation) {
 			return animation.chart === chart;
 		});
 
diff --git a/src/core/core.controller.js b/src/core/core.controller.js
index a5eaa5c03b1..c9e96ea4e21 100644
--- a/src/core/core.controller.js
+++ b/src/core/core.controller.js
@@ -33,7 +33,7 @@ module.exports = function(Chart) {
 		data.datasets = data.datasets || [];
 		data.labels = data.labels || [];
 
-		config.options = helpers.configMerge(
+		config.options = helpers.utility.configMerge(
 			defaults.global,
 			defaults[config.type],
 			config.options || {});
@@ -52,7 +52,7 @@ module.exports = function(Chart) {
 			layouts.removeBox(chart, scale);
 		});
 
-		newOptions = helpers.configMerge(
+		newOptions = helpers.utility.configMerge(
 			Chart.defaults.global,
 			Chart.defaults[chart.config.type],
 			newOptions);
diff --git a/src/core/core.layouts.js b/src/core/core.layouts.js
index 44ef9025c1d..5212a0c7b06 100644
--- a/src/core/core.layouts.js
+++ b/src/core/core.layouts.js
@@ -3,7 +3,7 @@
 var helpers = require('../helpers/helpers.core');
 
 function filterByPosition(array, position) {
-	return helpers.where(array, function(v) {
+	return helpers.utility.where(array, function(v) {
 		return v.position === position;
 	});
 }
@@ -237,7 +237,7 @@ module.exports = {
 
 		// Function to fit a box
 		function fitBox(box) {
-			var minBoxSize = helpers.findNextWhere(minBoxSizes, function(minBox) {
+			var minBoxSize = helpers.utility.findNextWhere(minBoxSizes, function(minBox) {
 				return minBox.box === box;
 			});
 
@@ -283,7 +283,7 @@ module.exports = {
 		});
 
 		function finalFitVerticalBox(box) {
-			var minBoxSize = helpers.findNextWhere(minBoxSizes, function(minSize) {
+			var minBoxSize = helpers.utility.findNextWhere(minBoxSizes, function(minSize) {
 				return minSize.box === box;
 			});
 
diff --git a/src/core/core.helpers.js b/src/helpers/helpers.utility.js
similarity index 82%
rename from src/core/core.helpers.js
rename to src/helpers/helpers.utility.js
index 7699167e89d..89d7a7c2637 100644
--- a/src/core/core.helpers.js
+++ b/src/helpers/helpers.utility.js
@@ -1,15 +1,13 @@
-/* global window: false */
-/* global document: false */
 'use strict';
 
-var helpers = require('../helpers/index');
+var helpers = require('./helpers.core');
 var scaleService = require('../core/core.scaleService');
 
-module.exports = function() {
-
-	// -- Basic js utility methods
-
-	helpers.configMerge = function(/* objects ... */) {
+/**
+ * @namespace Chart.helpers.utility
+ */
+module.exports = {
+	configMerge: function(/* objects ... */) {
 		return helpers.merge(helpers.clone(arguments[0]), [].slice.call(arguments, 1), {
 			merger: function(key, target, source, options) {
 				var tval = target[key] || {};
@@ -17,7 +15,7 @@ module.exports = function() {
 
 				if (key === 'scales') {
 					// scale config merging is complex. Add our own function here for that
-					target[key] = helpers.scaleMerge(tval, sval);
+					target[key] = helpers.utility.scaleMerge(tval, sval);
 				} else if (key === 'scale') {
 					// used in polar area & radar charts since there is only one scale
 					target[key] = helpers.merge(tval, [scaleService.getScaleDefaults(sval.type), sval]);
@@ -26,9 +24,9 @@ module.exports = function() {
 				}
 			}
 		});
-	};
+	},
 
-	helpers.scaleMerge = function(/* objects ... */) {
+	scaleMerge: function(/* objects ... */) {
 		return helpers.merge(helpers.clone(arguments[0]), [].slice.call(arguments, 1), {
 			merger: function(key, target, source, options) {
 				if (key === 'xAxes' || key === 'yAxes') {
@@ -61,9 +59,9 @@ module.exports = function() {
 				}
 			}
 		});
-	};
+	},
 
-	helpers.where = function(collection, filterCallback) {
+	where: function(collection, filterCallback) {
 		if (helpers.isArray(collection) && Array.prototype.filter) {
 			return collection.filter(filterCallback);
 		}
@@ -76,8 +74,9 @@ module.exports = function() {
 		});
 
 		return filtered;
-	};
-	helpers.findIndex = Array.prototype.findIndex ?
+	},
+
+	findIndex: Array.prototype.findIndex ?
 		function(array, callback, scope) {
 			return array.findIndex(callback, scope);
 		} :
@@ -89,8 +88,9 @@ module.exports = function() {
 				}
 			}
 			return -1;
-		};
-	helpers.findNextWhere = function(arrayToSearch, filterCallback, startIndex) {
+		},
+
+	findNextWhere: function(arrayToSearch, filterCallback, startIndex) {
 		// Default to start of the array
 		if (helpers.isNullOrUndef(startIndex)) {
 			startIndex = -1;
@@ -101,8 +101,9 @@ module.exports = function() {
 				return currentItem;
 			}
 		}
-	};
-	helpers.findPreviousWhere = function(arrayToSearch, filterCallback, startIndex) {
+	},
+
+	findPreviousWhere: function(arrayToSearch, filterCallback, startIndex) {
 		// Default to end of the array
 		if (helpers.isNullOrUndef(startIndex)) {
 			startIndex = arrayToSearch.length;
@@ -113,5 +114,5 @@ module.exports = function() {
 				return currentItem;
 			}
 		}
-	};
+	}
 };
diff --git a/src/helpers/index.js b/src/helpers/index.js
index 02a67bdb6c2..ab03a181184 100644
--- a/src/helpers/index.js
+++ b/src/helpers/index.js
@@ -6,3 +6,4 @@ module.exports.canvas = require('./helpers.canvas');
 module.exports.options = require('./helpers.options');
 module.exports.math = require('./helpers.math');
 module.exports.dom = require('./helpers.dom');
+module.exports.utility = require('./helpers.utility');
diff --git a/test/specs/core.helpers.tests.js b/test/specs/core.helpers.tests.js
index e1b5d29135c..17849812573 100644
--- a/test/specs/core.helpers.tests.js
+++ b/test/specs/core.helpers.tests.js
@@ -6,186 +6,6 @@ describe('Core helper tests', function() {
 		helpers = window.Chart.helpers;
 	});
 
-	it('should merge a normal config without scales', function() {
-		var baseConfig = {
-			valueProp: 5,
-			arrayProp: [1, 2, 3, 4, 5, 6],
-			objectProp: {
-				prop1: 'abc',
-				prop2: 56
-			}
-		};
-
-		var toMerge = {
-			valueProp2: null,
-			arrayProp: ['a', 'c'],
-			objectProp: {
-				prop1: 'c',
-				prop3: 'prop3'
-			}
-		};
-
-		var merged = helpers.configMerge(baseConfig, toMerge);
-		expect(merged).toEqual({
-			valueProp: 5,
-			valueProp2: null,
-			arrayProp: ['a', 'c'],
-			objectProp: {
-				prop1: 'c',
-				prop2: 56,
-				prop3: 'prop3'
-			}
-		});
-	});
-
-	it('should merge scale configs', function() {
-		var baseConfig = {
-			scales: {
-				prop1: {
-					abc: 123,
-					def: '456'
-				},
-				prop2: 777,
-				yAxes: [{
-					type: 'linear',
-				}, {
-					type: 'log'
-				}]
-			}
-		};
-
-		var toMerge = {
-			scales: {
-				prop1: {
-					def: 'bbb',
-					ghi: 78
-				},
-				prop2: null,
-				yAxes: [{
-					type: 'linear',
-					axisProp: 456
-				}, {
-					// pulls in linear default config since axis type changes
-					type: 'linear',
-					position: 'right'
-				}, {
-					// Pulls in linear default config since axis not in base
-					type: 'linear'
-				}]
-			}
-		};
-
-		var merged = helpers.configMerge(baseConfig, toMerge);
-		expect(merged).toEqual({
-			scales: {
-				prop1: {
-					abc: 123,
-					def: 'bbb',
-					ghi: 78
-				},
-				prop2: null,
-				yAxes: [{
-					type: 'linear',
-					axisProp: 456
-				}, {
-					display: true,
-
-					gridLines: {
-						color: 'rgba(0, 0, 0, 0.1)',
-						drawBorder: true,
-						drawOnChartArea: true,
-						drawTicks: true, // draw ticks extending towards the label
-						tickMarkLength: 10,
-						lineWidth: 1,
-						offsetGridLines: false,
-						display: true,
-						zeroLineColor: 'rgba(0,0,0,0.25)',
-						zeroLineWidth: 1,
-						zeroLineBorderDash: [],
-						zeroLineBorderDashOffset: 0.0,
-						borderDash: [],
-						borderDashOffset: 0.0
-					},
-					position: 'right',
-					offset: false,
-					scaleLabel: Chart.defaults.scale.scaleLabel,
-					ticks: {
-						beginAtZero: false,
-						minRotation: 0,
-						maxRotation: 50,
-						mirror: false,
-						padding: 0,
-						reverse: false,
-						display: true,
-						callback: merged.scales.yAxes[1].ticks.callback, // make it nicer, then check explicitly below
-						autoSkip: true,
-						autoSkipPadding: 0,
-						labelOffset: 0,
-						minor: {},
-						major: {},
-					},
-					type: 'linear'
-				}, {
-					display: true,
-
-					gridLines: {
-						color: 'rgba(0, 0, 0, 0.1)',
-						drawBorder: true,
-						drawOnChartArea: true,
-						drawTicks: true, // draw ticks extending towards the label,
-						tickMarkLength: 10,
-						lineWidth: 1,
-						offsetGridLines: false,
-						display: true,
-						zeroLineColor: 'rgba(0,0,0,0.25)',
-						zeroLineWidth: 1,
-						zeroLineBorderDash: [],
-						zeroLineBorderDashOffset: 0.0,
-						borderDash: [],
-						borderDashOffset: 0.0
-					},
-					position: 'left',
-					offset: false,
-					scaleLabel: Chart.defaults.scale.scaleLabel,
-					ticks: {
-						beginAtZero: false,
-						minRotation: 0,
-						maxRotation: 50,
-						mirror: false,
-						padding: 0,
-						reverse: false,
-						display: true,
-						callback: merged.scales.yAxes[2].ticks.callback, // make it nicer, then check explicitly below
-						autoSkip: true,
-						autoSkipPadding: 0,
-						labelOffset: 0,
-						minor: {},
-						major: {},
-					},
-					type: 'linear'
-				}]
-			}
-		});
-
-		// Are these actually functions
-		expect(merged.scales.yAxes[1].ticks.callback).toEqual(jasmine.any(Function));
-		expect(merged.scales.yAxes[2].ticks.callback).toEqual(jasmine.any(Function));
-	});
-
-	it('should filter an array', function() {
-		var data = [-10, 0, 6, 0, 7];
-		var callback = function(item) {
-			return item > 2;
-		};
-		expect(helpers.where(data, callback)).toEqual([6, 7]);
-		expect(helpers.findNextWhere(data, callback)).toEqual(6);
-		expect(helpers.findNextWhere(data, callback, 2)).toBe(7);
-		expect(helpers.findNextWhere(data, callback, 4)).toBe(undefined);
-		expect(helpers.findPreviousWhere(data, callback)).toBe(7);
-		expect(helpers.findPreviousWhere(data, callback, 3)).toBe(6);
-		expect(helpers.findPreviousWhere(data, callback, 0)).toBe(undefined);
-	});
-
 	it('should generate integer ids', function() {
 		var uid = helpers.uid();
 		expect(uid).toEqual(jasmine.any(Number));
diff --git a/test/specs/helpers.utility.tests.js b/test/specs/helpers.utility.tests.js
new file mode 100644
index 00000000000..0b432a4ac07
--- /dev/null
+++ b/test/specs/helpers.utility.tests.js
@@ -0,0 +1,188 @@
+describe('Utility helper tests', function() {
+
+	var helpers;
+
+	beforeAll(function() {
+		helpers = window.Chart.helpers;
+	});
+
+	it('should merge a normal config without scales', function() {
+		var baseConfig = {
+			valueProp: 5,
+			arrayProp: [1, 2, 3, 4, 5, 6],
+			objectProp: {
+				prop1: 'abc',
+				prop2: 56
+			}
+		};
+
+		var toMerge = {
+			valueProp2: null,
+			arrayProp: ['a', 'c'],
+			objectProp: {
+				prop1: 'c',
+				prop3: 'prop3'
+			}
+		};
+
+		var merged = helpers.utility.configMerge(baseConfig, toMerge);
+		expect(merged).toEqual({
+			valueProp: 5,
+			valueProp2: null,
+			arrayProp: ['a', 'c'],
+			objectProp: {
+				prop1: 'c',
+				prop2: 56,
+				prop3: 'prop3'
+			}
+		});
+	});
+
+	it('should merge scale configs', function() {
+		var baseConfig = {
+			scales: {
+				prop1: {
+					abc: 123,
+					def: '456'
+				},
+				prop2: 777,
+				yAxes: [{
+					type: 'linear',
+				}, {
+					type: 'log'
+				}]
+			}
+		};
+
+		var toMerge = {
+			scales: {
+				prop1: {
+					def: 'bbb',
+					ghi: 78
+				},
+				prop2: null,
+				yAxes: [{
+					type: 'linear',
+					axisProp: 456
+				}, {
+					// pulls in linear default config since axis type changes
+					type: 'linear',
+					position: 'right'
+				}, {
+					// Pulls in linear default config since axis not in base
+					type: 'linear'
+				}]
+			}
+		};
+
+		var merged = helpers.utility.configMerge(baseConfig, toMerge);
+		expect(merged).toEqual({
+			scales: {
+				prop1: {
+					abc: 123,
+					def: 'bbb',
+					ghi: 78
+				},
+				prop2: null,
+				yAxes: [{
+					type: 'linear',
+					axisProp: 456
+				}, {
+					display: true,
+
+					gridLines: {
+						color: 'rgba(0, 0, 0, 0.1)',
+						drawBorder: true,
+						drawOnChartArea: true,
+						drawTicks: true, // draw ticks extending towards the label
+						tickMarkLength: 10,
+						lineWidth: 1,
+						offsetGridLines: false,
+						display: true,
+						zeroLineColor: 'rgba(0,0,0,0.25)',
+						zeroLineWidth: 1,
+						zeroLineBorderDash: [],
+						zeroLineBorderDashOffset: 0.0,
+						borderDash: [],
+						borderDashOffset: 0.0
+					},
+					position: 'right',
+					offset: false,
+					scaleLabel: Chart.defaults.scale.scaleLabel,
+					ticks: {
+						beginAtZero: false,
+						minRotation: 0,
+						maxRotation: 50,
+						mirror: false,
+						padding: 0,
+						reverse: false,
+						display: true,
+						callback: merged.scales.yAxes[1].ticks.callback, // make it nicer, then check explicitly below
+						autoSkip: true,
+						autoSkipPadding: 0,
+						labelOffset: 0,
+						minor: {},
+						major: {},
+					},
+					type: 'linear'
+				}, {
+					display: true,
+
+					gridLines: {
+						color: 'rgba(0, 0, 0, 0.1)',
+						drawBorder: true,
+						drawOnChartArea: true,
+						drawTicks: true, // draw ticks extending towards the label,
+						tickMarkLength: 10,
+						lineWidth: 1,
+						offsetGridLines: false,
+						display: true,
+						zeroLineColor: 'rgba(0,0,0,0.25)',
+						zeroLineWidth: 1,
+						zeroLineBorderDash: [],
+						zeroLineBorderDashOffset: 0.0,
+						borderDash: [],
+						borderDashOffset: 0.0
+					},
+					position: 'left',
+					offset: false,
+					scaleLabel: Chart.defaults.scale.scaleLabel,
+					ticks: {
+						beginAtZero: false,
+						minRotation: 0,
+						maxRotation: 50,
+						mirror: false,
+						padding: 0,
+						reverse: false,
+						display: true,
+						callback: merged.scales.yAxes[2].ticks.callback, // make it nicer, then check explicitly below
+						autoSkip: true,
+						autoSkipPadding: 0,
+						labelOffset: 0,
+						minor: {},
+						major: {},
+					},
+					type: 'linear'
+				}]
+			}
+		});
+
+		// Are these actually functions
+		expect(merged.scales.yAxes[1].ticks.callback).toEqual(jasmine.any(Function));
+		expect(merged.scales.yAxes[2].ticks.callback).toEqual(jasmine.any(Function));
+	});
+
+	it('should filter an array', function() {
+		var data = [-10, 0, 6, 0, 7];
+		var callback = function(item) {
+			return item > 2;
+		};
+		expect(helpers.utility.where(data, callback)).toEqual([6, 7]);
+		expect(helpers.utility.findNextWhere(data, callback)).toEqual(6);
+		expect(helpers.utility.findNextWhere(data, callback, 2)).toBe(7);
+		expect(helpers.utility.findNextWhere(data, callback, 4)).toBe(undefined);
+		expect(helpers.utility.findPreviousWhere(data, callback)).toBe(7);
+		expect(helpers.utility.findPreviousWhere(data, callback, 3)).toBe(6);
+		expect(helpers.utility.findPreviousWhere(data, callback, 0)).toBe(undefined);
+	});
+});