https://tofas.com.tr/_catalogs/masterpage/bower_components/chart.js/dist/Chart.js

1/*!
2 * Chart.js
3 * http://chartjs.org/
4 * Version: 2.7.2
5 *
6 * Copyright 2018 Chart.js Contributors
7 * Released under the MIT license
8 * https://github.com/chartjs/Chart.js/blob/master/LICENSE.md
9 */
10(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Chart = f()}})(function(){var define,module,exports;return (function(){function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}return e})()({1:[function(require,module,exports){
11
12},{}],2:[function(require,module,exports){
13/* MIT license */
14var colorNames = require(6);
15
16module.exports = {
17   getRgba: getRgba,
18   getHsla: getHsla,
19   getRgb: getRgb,
20   getHsl: getHsl,
21   getHwb: getHwb,
22   getAlpha: getAlpha,
23
24   hexString: hexString,
25   rgbString: rgbString,
26   rgbaString: rgbaString,
27   percentString: percentString,
28   percentaString: percentaString,
29   hslString: hslString,
30   hslaString: hslaString,
31   hwbString: hwbString,
32   keyword: keyword
33}
34
35function getRgba(string) {
36   if (!string) {
37      return;
38   }
39   var abbr =  /^#([a-fA-F0-9]{3})$/i,
40       hex =  /^#([a-fA-F0-9]{6})$/i,
41       rgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
42       per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
43       keyword = /(\w+)/;
44
45   var rgb = [0, 0, 0],
46       a = 1,
47       match = string.match(abbr);
48   if (match) {
49      match = match[1];
50      for (var i = 0; i < rgb.length; i++) {
51         rgb[i] = parseInt(match[i] + match[i], 16);
52      }
53   }
54   else if (match = string.match(hex)) {
55      match = match[1];
56      for (var i = 0; i < rgb.length; i++) {
57         rgb[i] = parseInt(match.slice(i * 2, i * 2 + 2), 16);
58      }
59   }
60   else if (match = string.match(rgba)) {
61      for (var i = 0; i < rgb.length; i++) {
62         rgb[i] = parseInt(match[i + 1]);
63      }
64      a = parseFloat(match[4]);
65   }
66   else if (match = string.match(per)) {
67      for (var i = 0; i < rgb.length; i++) {
68         rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
69      }
70      a = parseFloat(match[4]);
71   }
72   else if (match = string.match(keyword)) {
73      if (match[1] == "transparent") {
74         return [0, 0, 0, 0];
75      }
76      rgb = colorNames[match[1]];
77      if (!rgb) {
78         return;
79      }
80   }
81
82   for (var i = 0; i < rgb.length; i++) {
83      rgb[i] = scale(rgb[i], 0, 255);
84   }
85   if (!a && a != 0) {
86      a = 1;
87   }
88   else {
89      a = scale(a, 0, 1);
90   }
91   rgb[3] = a;
92   return rgb;
93}
94
95function getHsla(string) {
96   if (!string) {
97      return;
98   }
99   var hsl = /^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/;
100   var match = string.match(hsl);
101   if (match) {
102      var alpha = parseFloat(match[4]);
103      var h = scale(parseInt(match[1]), 0, 360),
104          s = scale(parseFloat(match[2]), 0, 100),
105          l = scale(parseFloat(match[3]), 0, 100),
106          a = scale(isNaN(alpha) ? 1 : alpha, 0, 1);
107      return [h, s, l, a];
108   }
109}
110
111function getHwb(string) {
112   if (!string) {
113      return;
114   }
115   var hwb = /^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/;
116   var match = string.match(hwb);
117   if (match) {
118    var alpha = parseFloat(match[4]);
119      var h = scale(parseInt(match[1]), 0, 360),
120          w = scale(parseFloat(match[2]), 0, 100),
121          b = scale(parseFloat(match[3]), 0, 100),
122          a = scale(isNaN(alpha) ? 1 : alpha, 0, 1);
123      return [h, w, b, a];
124   }
125}
126
127function getRgb(string) {
128   var rgba = getRgba(string);
129   return rgba && rgba.slice(0, 3);
130}
131
132function getHsl(string) {
133  var hsla = getHsla(string);
134  return hsla && hsla.slice(0, 3);
135}
136
137function getAlpha(string) {
138   var vals = getRgba(string);
139   if (vals) {
140      return vals[3];
141   }
142   else if (vals = getHsla(string)) {
143      return vals[3];
144   }
145   else if (vals = getHwb(string)) {
146      return vals[3];
147   }
148}
149
150// generators
151function hexString(rgb) {
152   return "#" + hexDouble(rgb[0]) + hexDouble(rgb[1])
153              + hexDouble(rgb[2]);
154}
155
156function rgbString(rgba, alpha) {

157   if (alpha < 1 || (rgba[3] && rgba[3] < 1)) {
158      return rgbaString(rgba, alpha);
159   }
160   return "rgb(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2] + ")";
161}
162
163function rgbaString(rgba, alpha) {
164   if (alpha === undefined) {
165      alpha = (rgba[3] !== undefined ? rgba[3] : 1);
166   }
167   return "rgba(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2]
168           + ", " + alpha + ")";
169}
170
171function percentString(rgba, alpha) {
172   if (alpha < 1 || (rgba[3] && rgba[3] < 1)) {
173      return percentaString(rgba, alpha);
174   }
175   var r = Math.round(rgba[0]/255 * 100),
176       g = Math.round(rgba[1]/255 * 100),
177       b = Math.round(rgba[2]/255 * 100);
178
179   return "rgb(" + r + "%, " + g + "%, " + b + "%)";
180}
181
182function percentaString(rgba, alpha) {
183   var r = Math.round(rgba[0]/255 * 100),
184       g = Math.round(rgba[1]/255 * 100),
185       b = Math.round(rgba[2]/255 * 100);
186   return "rgba(" + r + "%, " + g + "%, " + b + "%, " + (alpha || rgba[3] || 1) + ")";
187}
188
189function hslString(hsla, alpha) {
190   if (alpha < 1 || (hsla[3] && hsla[3] < 1)) {
191      return hslaString(hsla, alpha);
192   }
193   return "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)";
194}
195
196function hslaString(hsla, alpha) {
197   if (alpha === undefined) {
198      alpha = (hsla[3] !== undefined ? hsla[3] : 1);
199   }
200   return "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, "
201           + alpha + ")";
202}
203
204// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax
205// (hwb have alpha optional & 1 is default value)
206function hwbString(hwb, alpha) {
207   if (alpha === undefined) {
208      alpha = (hwb[3] !== undefined ? hwb[3] : 1);
209   }
210   return "hwb(" + hwb[0] + ", " + hwb[1] + "%, " + hwb[2] + "%"
211           + (alpha !== undefined && alpha !== 1 ? ", " + alpha : "") + ")";
212}
213
214function keyword(rgb) {
215  return reverseNames[rgb.slice(0, 3)];
216}
217
218// helpers
219function scale(num, min, max) {
220   return Math.min(Math.max(min, num), max);
221}
222
223function hexDouble(num) {
224  var str = num.toString(16).toUpperCase();
225  return (str.length < 2) ? "0" + str : str;
226}
227
228
229//create a list of reverse color names
230var reverseNames = {};
231for (var name in colorNames) {
232   reverseNames[colorNames[name]] = name;
233}
234
235},{"6":6}],3:[function(require,module,exports){
236/* MIT license */
237var convert = require(5);
238var string = require(2);
239
240var Color = function (obj) {
241	if (obj instanceof Color) {
242		return obj;
243	}
244	if (!(this instanceof Color)) {
245		return new Color(obj);
246	}
247
248	this.valid = false;
249	this.values = {
250		rgb: [0, 0, 0],
251		hsl: [0, 0, 0],
252		hsv: [0, 0, 0],
253		hwb: [0, 0, 0],
254		cmyk: [0, 0, 0, 0],
255		alpha: 1
256	};
257
258	// parse Color() argument
259	var vals;
260	if (typeof obj === 'string') {
261		vals = string.getRgba(obj);
262		if (vals) {
263			this.setValues('rgb', vals);
264		} else if (vals = string.getHsla(obj)) {
265			this.setValues('hsl', vals);
266		} else if (vals = string.getHwb(obj)) {
267			this.setValues('hwb', vals);
268		}
269	} else if (typeof obj === 'object') {
270		vals = obj;
271		if (vals.r !== undefined || vals.red !== undefined) {
272			this.setValues('rgb', vals);
273		} else if (vals.l !== undefined || vals.lightness !== undefined) {
274			this.setValues('hsl', vals);
275		} else if (vals.v !== undefined || vals.value !== undefined) {
276			this.setValues('hsv', vals);
277		} else if (vals.w !== undefined || vals.whiteness !== undefined) {
278			this.setValues('hwb', vals);
279		} else if (vals.c !== undefined || vals.cyan !== undefined) {
280			this.setValues('cmyk', vals);
281		}
282	}
283};
284
285Color.prototype = {
286	isValid: function () {
287		return this.valid;
288	},
289	rgb: function () {
290		return this.setSpace('rgb', arguments);
291	},
292	hsl: function () {
293		return this.setSpace('hsl', arguments);
294	},
295	hsv: function () {
296		return this.setSpace('hsv', arguments);
297	},
298	hwb: function () {
299		return this.setSpace('hwb', arguments);
300	},
301	cmyk: function () {
302		return this.setSpace('cmyk', arguments);
303	},
304
305	rgbArray: function () {
306		return this.values.rgb;
307	},
308	hslArray: function () {
309		return this.values.hsl;
310	},
311	hsvArray: function () {
312		return this.values.hsv;
313	},
314	hwbArray: function () {
315		var values = this.values;
316		if (values.alpha !== 1) {
317			return values.hwb.concat([values.alpha]);
318		}
319		return values.hwb;
320	},
321	cmykArray: function () {
322		return this.values.cmyk;
323	},
324	rgbaArray: function () {
325		var values = this.values;
326		return values.rgb.concat([values.alpha]);
327	},
328	hslaArray: function () {
329		var values = this.values;
330		return values.hsl.concat([values.alpha]);
331	},
332	alpha: function (val) {
333		if (val === undefined) {
334			return this.values.alpha;
335		}
336		this.setValues('alpha', val);
337		return this;
338	},
339
340	red: function (val) {
341		return this.setChannel('rgb', 0, val);
342	},
343	green: function (val) {
344		return this.setChannel('rgb', 1, val);
345	},
346	blue: function (val) {
347		return this.setChannel('rgb', 2, val);
348	},
349	hue: function (val) {
350		if (val) {
351			val %= 360;
352			val = val < 0 ? 360 + val : val;
353		}
354		return this.setChannel('hsl', 0, val);
355	},
356	saturation: function (val) {
357		return this.setChannel('hsl', 1, val);
358	},
359	lightness: function (val) {
360		return this.setChannel('hsl', 2, val);
361	},
362	saturationv: function (val) {
363		return this.setChannel('hsv', 1, val);
364	},
365	whiteness: function (val) {
366		return this.setChannel('hwb', 1, val);
367	},
368	blackness: function (val) {
369		return this.setChannel('hwb', 2, val);
370	},
371	value: function (val) {
372		return this.setChannel('hsv', 2, val);
373	},
374	cyan: function (val) {
375		return this.setChannel('cmyk', 0, val);
376	},
377	magenta: function (val) {
378		return this.setChannel('cmyk', 1, val);
379	},
380	yellow: function (val) {
381		return this.setChannel('cmyk', 2, val);
382	},
383	black: function (val) {
384		return this.setChannel('cmyk', 3, val);
385	},
386
387	hexString: function () {
388		return string.hexString(this.values.rgb);
389	},
390	rgbString: function () {
391		return string.rgbString(this.values.rgb, this.values.alpha);
392	},
393	rgbaString: function () {
394		return string.rgbaString(this.values.rgb, this.values.alpha);
395	},
396	percentString: function () {
397		return string.percentString(this.values.rgb, this.values.alpha);
398	},
399	hslString: function () {
400		return string.hslString(this.values.hsl, this.values.alpha);
401	},
402	hslaString: function () {
403		return string.hslaString(this.values.hsl, this.values.alpha);
404	},
405	hwbString: function () {
406		return string.hwbString(this.values.hwb, this.values.alpha);
407	},
408	keyword: function () {
409		return string.keyword(this.values.rgb, this.values.alpha);
410	},
411
412	rgbNumber: function () {
413		var rgb = this.values.rgb;
414		return (rgb[0] << 16) | (rgb[1] << 8) | rgb[2];
415	},
416
417	luminosity: function () {
418		// http://www.w3.org/TR/WCAG20/#relativeluminancedef
419		var rgb = this.values.rgb;
420		var lum = [];
421		for (var i = 0; i < rgb.length; i++) {
422			var chan = rgb[i] / 255;
423			lum[i] = (chan <= 0.03928) ? chan / 12.92 : Math.pow(((chan + 0.055) / 1.055), 2.4);
424		}
425		return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
426	},
427
428	contrast: function (color2) {
429		// http://www.w3.org/TR/WCAG20/#contrast-ratiodef
430		var lum1 = this.luminosity();
431		var lum2 = color2.luminosity();
432		if (lum1 > lum2) {
433			return (lum1 + 0.05) / (lum2 + 0.05);
434		}
435		return (lum2 + 0.05) / (lum1 + 0.05);
436	},
437
438	level: function (color2) {
439		var contrastRatio = this.contrast(color2);
440		if (contrastRatio >= 7.1) {
441			return 'AAA';
442		}
443
444		return (contrastRatio >= 4.5) ? 'AA' : '';
445	},
446
447	dark: function () {
448		// YIQ equation from http://24ways.org/2010/calculating-color-contrast
449		var rgb = this.values.rgb;
450		var yiq = (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1000;
451		return yiq < 128;
452	},
453
454	light: function () {
455		return !this.dark();
456	},
457
458	negate: function () {
459		var rgb = [];
460		for (var i = 0; i < 3; i++) {
461			rgb[i] = 255 - this.values.rgb[i];
462		}
463		this.setValues('rgb', rgb);
464		return this;
465	},
466
467	lighten: function (ratio) {
468		var hsl = this.values.hsl;
469		hsl[2] += hsl[2] * ratio;
470		this.setValues('hsl', hsl);
471		return this;
472	},
473
474	darken: function (ratio) {
475		var hsl = this.values.hsl;
476		hsl[2] -= hsl[2] * ratio;
477		this.setValues('hsl', hsl);
478		return this;
479	},
480
481	saturate: function (ratio) {
482		var hsl = this.values.hsl;
483		hsl[1] += hsl[1] * ratio;
484		this.setValues('hsl', hsl);
485		return this;
486	},
487
488	desaturate: function (ratio) {
489		var hsl = this.values.hsl;
490		hsl[1] -= hsl[1] * ratio;
491		this.setValues('hsl', hsl);
492		return this;
493	},
494
495	whiten: function (ratio) {
496		var hwb = this.values.hwb;
497		hwb[1] += hwb[1] * ratio;
498		this.setValues('hwb', hwb);
499		return this;
500	},
501
502	blacken: function (ratio) {
503		var hwb = this.values.hwb;
504		hwb[2] += hwb[2] * ratio;
505		this.setValues('hwb', hwb);
506		return this;
507	},
508
509	greyscale: function () {
510		var rgb = this.values.rgb;
511		// http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale
512		var val = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
513		this.setValues('rgb', [val, val, val]);
514		return this;
515	},
516
517	clearer: function (ratio) {
518		var alpha = this.values.alpha;
519		this.setValues('alpha', alpha - (alpha * ratio));
520		return this;
521	},
522
523	opaquer: function (ratio) {
524		var alpha = this.values.alpha;
525		this.setValues('alpha', alpha + (alpha * ratio));
526		return this;
527	},
528
529	rotate: function (degrees) {
530		var hsl = this.values.hsl;
531		var hue = (hsl[0] + degrees) % 360;
532		hsl[0] = hue < 0 ? 360 + hue : hue;
533		this.setValues('hsl', hsl);
534		return this;
535	},
536
537	/**
538	 * Ported from sass implementation in C
539	 * https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209
540	 */
541	mix: function (mixinColor, weight) {
542		var color1 = this;
543		var color2 = mixinColor;
544		var p = weight === undefined ? 0.5 : weight;
545
546		var w = 2 * p - 1;
547		var a = color1.alpha() - color2.alpha();
548
549		var w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
550		var w2 = 1 - w1;
551
552		return this
553			.rgb(
554				w1 * color1.red() + w2 * color2.red(),
555				w1 * color1.green() + w2 * color2.green(),
556				w1 * color1.blue() + w2 * color2.blue()
557			)
558			.alpha(color1.alpha() * p + color2.alpha() * (1 - p));
559	},
560
561	toJSON: function () {
562		return this.rgb();
563	},
564
565	clone: function () {
566		// NOTE(SB): using node-clone creates a dependency to Buffer when using browserify,
567		// making the final build way to big to embed in Chart.js. So let's do it manually,
568		// assuming that values to clone are 1 dimension arrays containing only numbers,
569		// except 'alpha' which is a number.
570		var result = new Color();
571		var source = this.values;
572		var target = result.values;
573		var value, type;
574
575		for (var prop in source) {
576			if (source.hasOwnProperty(prop)) {
577				value = source[prop];
578				type = ({}).toString.call(value);
579				if (type === '[object Array]') {
580					target[prop] = value.slice(0);
581				} else if (type === '[object Number]') {
582					target[prop] = value;
583				} else {
584					console.error('unexpected color value:', value);
585				}
586			}
587		}
588
589		return result;
590	}
591};
592
593Color.prototype.spaces = {
594	rgb: ['red', 'green', 'blue'],
595	hsl: ['hue', 'saturation', 'lightness'],
596	hsv: ['hue', 'saturation', 'value'],
597	hwb: ['hue', 'whiteness', 'blackness'],
598	cmyk: ['cyan', 'magenta', 'yellow', 'black']
599};
600
601Color.prototype.maxes = {
602	rgb: [255, 255, 255],
603	hsl: [360, 100, 100],
604	hsv: [360, 100, 100],
605	hwb: [360, 100, 100],
606	cmyk: [100, 100, 100, 100]
607};
608
609Color.prototype.getValues = function (space) {
610	var values = this.values;
611	var vals = {};
612
613	for (var i = 0; i < space.length; i++) {
614		vals[space.charAt(i)] = values[space][i];
615	}
616
617	if (values.alpha !== 1) {
618		vals.a = values.alpha;
619	}
620
621	// {r: 255, g: 255, b: 255, a: 0.4}
622	return vals;
623};
624
625Color.prototype.setValues = function (space, vals) {
626	var values = this.values;
627	var spaces = this.spaces;
628	var maxes = this.maxes;
629	var alpha = 1;
630	var i;
631
632	this.valid = true;
633
634	if (space === 'alpha') {
635		alpha = vals;
636	} else if (vals.length) {
637		// [10, 10, 10]
638		values[space] = vals.slice(0, space.length);
639		alpha = vals[space.length];
640	} else if (vals[space.charAt(0)] !== undefined) {
641		// {r: 10, g: 10, b: 10}
642		for (i = 0; i < space.length; i++) {
643			values[space][i] = vals[space.charAt(i)];
644		}
645
646		alpha = vals.a;
647	} else if (vals[spaces[space][0]] !== undefined) {
648		// {red: 10, green: 10, blue: 10}
649		var chans = spaces[space];
650
651		for (i = 0; i < space.length; i++) {
652			values[space][i] = vals[chans[i]];
653		}
654
655		alpha = vals.alpha;
656	}
657
658	values.alpha = Math.max(0, Math.min(1, (alpha === undefined ? values.alpha : alpha)));
659
660	if (space === 'alpha') {
661		return false;
662	}
663
664	var capped;
665
666	// cap values of the space prior converting all values
667	for (i = 0; i < space.length; i++) {
668		capped = Math.max(0, Math.min(maxes[space][i], values[space][i]));
669		values[space][i] = Math.round(capped);
670	}
671
672	// convert to all the other color spaces
673	for (var sname in spaces) {
674		if (sname !== space) {
675			values[sname] = convert[space][sname](values[space]);
676		}
677	}
678
679	return true;
680};
681
682Color.prototype.setSpace = function (space, args) {
683	var vals = args[0];
684
685	if (vals === undefined) {
686		// color.rgb()
687		return this.getValues(space);
688	}
689
690	// color.rgb(10, 10, 10)
691	if (typeof vals === 'number') {
692		vals = Array.prototype.slice.call(args);
693	}
694
695	this.setValues(space, vals);
696	return this;
697};
698
699Color.prototype.setChannel = function (space, index, val) {
700	var svalues = this.values[space];
701	if (val === undefined) {
702		// color.red()
703		return svalues[index];
704	} else if (val === svalues[index]) {
705		// color.red(color.red())
706		return this;
707	}
708
709	// color.red(100)
710	svalues[index] = val;
711	this.setValues(space, svalues);
712
713	return this;
714};
715
716if (typeof window !== 'undefined') {
717	window.Color = Color;
718}
719
720module.exports = Color;
721
722},{"2":2,"5":5}],4:[function(require,module,exports){
723/* MIT license */
724
725module.exports = {
726  rgb2hsl: rgb2hsl,
727  rgb2hsv: rgb2hsv,
728  rgb2hwb: rgb2hwb,
729  rgb2cmyk: rgb2cmyk,
730  rgb2keyword: rgb2keyword,
731  rgb2xyz: rgb2xyz,
732  rgb2lab: rgb2lab,
733  rgb2lch: rgb2lch,
734
735  hsl2rgb: hsl2rgb,
736  hsl2hsv: hsl2hsv,
737  hsl2hwb: hsl2hwb,
738  hsl2cmyk: hsl2cmyk,
739  hsl2keyword: hsl2keyword,
740
741  hsv2rgb: hsv2rgb,
742  hsv2hsl: hsv2hsl,
743  hsv2hwb: hsv2hwb,
744  hsv2cmyk: hsv2cmyk,
745  hsv2keyword: hsv2keyword,
746
747  hwb2rgb: hwb2rgb,
748  hwb2hsl: hwb2hsl,
749  hwb2hsv: hwb2hsv,
750  hwb2cmyk: hwb2cmyk,
751  hwb2keyword: hwb2keyword,
752
753  cmyk2rgb: cmyk2rgb,
754  cmyk2hsl: cmyk2hsl,
755  cmyk2hsv: cmyk2hsv,
756  cmyk2hwb: cmyk2hwb,
757  cmyk2keyword: cmyk2keyword,
758
759  keyword2rgb: keyword2rgb,
760  keyword2hsl: keyword2hsl,
761  keyword2hsv: keyword2hsv,

762  keyword2hwb: keyword2hwb,
763  keyword2cmyk: keyword2cmyk,
764  keyword2lab: keyword2lab,
765  keyword2xyz: keyword2xyz,
766
767  xyz2rgb: xyz2rgb,
768  xyz2lab: xyz2lab,
769  xyz2lch: xyz2lch,
770
771  lab2xyz: lab2xyz,
772  lab2rgb: lab2rgb,
773  lab2lch: lab2lch,
774
775  lch2lab: lch2lab,
776  lch2xyz: lch2xyz,
777  lch2rgb: lch2rgb
778}
779
780
781function rgb2hsl(rgb) {
782  var r = rgb[0]/255,
783      g = rgb[1]/255,
784      b = rgb[2]/255,
785      min = Math.min(r, g, b),
786      max = Math.max(r, g, b),
787      delta = max - min,
788      h, s, l;
789
790  if (max == min)
791    h = 0;
792  else if (r == max)
793    h = (g - b) / delta;
794  else if (g == max)
795    h = 2 + (b - r) / delta;
796  else if (b == max)
797    h = 4 + (r - g)/ delta;
798
799  h = Math.min(h * 60, 360);
800
801  if (h < 0)
802    h += 360;
803
804  l = (min + max) / 2;
805
806  if (max == min)
807    s = 0;
808  else if (l <= 0.5)
809    s = delta / (max + min);
810  else
811    s = delta / (2 - max - min);
812
813  return [h, s * 100, l * 100];
814}
815
816function rgb2hsv(rgb) {
817  var r = rgb[0],
818      g = rgb[1],
819      b = rgb[2],
820      min = Math.min(r, g, b),
821      max = Math.max(r, g, b),
822      delta = max - min,
823      h, s, v;
824
825  if (max == 0)
826    s = 0;
827  else
828    s = (delta/max * 1000)/10;
829
830  if (max == min)
831    h = 0;
832  else if (r == max)
833    h = (g - b) / delta;
834  else if (g == max)
835    h = 2 + (b - r) / delta;
836  else if (b == max)
837    h = 4 + (r - g) / delta;
838
839  h = Math.min(h * 60, 360);
840
841  if (h < 0)
842    h += 360;
843
844  v = ((max / 255) * 1000) / 10;
845
846  return [h, s, v];
847}
848
849function rgb2hwb(rgb) {
850  var r = rgb[0],
851      g = rgb[1],
852      b = rgb[2],
853      h = rgb2hsl(rgb)[0],
854      w = 1/255 * Math.min(r, Math.min(g, b)),
855      b = 1 - 1/255 * Math.max(r, Math.max(g, b));
856
857  return [h, w * 100, b * 100];
858}
859
860function rgb2cmyk(rgb) {
861  var r = rgb[0] / 255,
862      g = rgb[1] / 255,
863      b = rgb[2] / 255,
864      c, m, y, k;
865
866  k = Math.min(1 - r, 1 - g, 1 - b);
867  c = (1 - r - k) / (1 - k) || 0;
868  m = (1 - g - k) / (1 - k) || 0;
869  y = (1 - b - k) / (1 - k) || 0;
870  return [c * 100, m * 100, y * 100, k * 100];
871}
872
873function rgb2keyword(rgb) {
874  return reverseKeywords[JSON.stringify(rgb)];
875}
876
877function rgb2xyz(rgb) {
878  var r = rgb[0] / 255,
879      g = rgb[1] / 255,
880      b = rgb[2] / 255;
881
882  // assume sRGB
883  r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
884  g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
885  b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
886
887  var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
888  var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
889  var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
890
891  return [x * 100, y *100, z * 100];
892}
893
894function rgb2lab(rgb) {
895  var xyz = rgb2xyz(rgb),
896        x = xyz[0],
897        y = xyz[1],
898        z = xyz[2],
899        l, a, b;
900
901  x /= 95.047;
902  y /= 100;
903  z /= 108.883;
904
905  x = x > 0.008856 ? Math.pow(x, 1/3) : (7.787 * x) + (16 / 116);
906  y = y > 0.008856 ? Math.pow(y, 1/3) : (7.787 * y) + (16 / 116);
907  z = z > 0.008856 ? Math.pow(z, 1/3) : (7.787 * z) + (16 / 116);
908
909  l = (116 * y) - 16;
910  a = 500 * (x - y);
911  b = 200 * (y - z);
912
913  return [l, a, b];
914}
915
916function rgb2lch(args) {
917  return lab2lch(rgb2lab(args));
918}
919
920function hsl2rgb(hsl) {
921  var h = hsl[0] / 360,
922      s = hsl[1] / 100,
923      l = hsl[2] / 100,
924      t1, t2, t3, rgb, val;
925
926  if (s == 0) {
927    val = l * 255;
928    return [val, val, val];
929  }
930
931  if (l < 0.5)
932    t2 = l * (1 + s);
933  else
934    t2 = l + s - l * s;
935  t1 = 2 * l - t2;
936
937  rgb = [0, 0, 0];
938  for (var i = 0; i < 3; i++) {
939    t3 = h + 1 / 3 * - (i - 1);
940    t3 < 0 && t3++;
941    t3 > 1 && t3--;
942
943    if (6 * t3 < 1)
944      val = t1 + (t2 - t1) * 6 * t3;
945    else if (2 * t3 < 1)
946      val = t2;
947    else if (3 * t3 < 2)
948      val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
949    else
950      val = t1;
951
952    rgb[i] = val * 255;
953  }
954
955  return rgb;
956}
957
958function hsl2hsv(hsl) {
959  var h = hsl[0],
960      s = hsl[1] / 100,
961      l = hsl[2] / 100,
962      sv, v;
963
964  if(l === 0) {
965      // no need to do calc on black
966      // also avoids divide by 0 error
967      return [0, 0, 0];
968  }
969
970  l *= 2;
971  s *= (l <= 1) ? l : 2 - l;
972  v = (l + s) / 2;
973  sv = (2 * s) / (l + s);
974  return [h, sv * 100, v * 100];
975}
976
977function hsl2hwb(args) {
978  return rgb2hwb(hsl2rgb(args));
979}
980
981function hsl2cmyk(args) {
982  return rgb2cmyk(hsl2rgb(args));
983}
984
985function hsl2keyword(args) {
986  return rgb2keyword(hsl2rgb(args));
987}
988
989
990function hsv2rgb(hsv) {

991  var h = hsv[0] / 60,
992      s = hsv[1] / 100,
993      v = hsv[2] / 100,
994      hi = Math.floor(h) % 6;
995
996  var f = h - Math.floor(h),
997      p = 255 * v * (1 - s),
998      q = 255 * v * (1 - (s * f)),
999      t = 255 * v * (1 - (s * (1 - f))),
1000      v = 255 * v;
1001
1002  switch(hi) {
1003    case 0:
1004      return [v, t, p];
1005    case 1:
1006      return [q, v, p];
1007    case 2:
1008      return [p, v, t];
1009    case 3:
1010      return [p, q, v];
1011    case 4:
1012      return [t, p, v];
1013    case 5:
1014      return [v, p, q];
1015  }
1016}
1017
1018function hsv2hsl(hsv) {
1019  var h = hsv[0],
1020      s = hsv[1] / 100,
1021      v = hsv[2] / 100,
1022      sl, l;
1023
1024  l = (2 - s) * v;
1025  sl = s * v;
1026  sl /= (l <= 1) ? l : 2 - l;
1027  sl = sl || 0;
1028  l /= 2;
1029  return [h, sl * 100, l * 100];
1030}
1031
1032function hsv2hwb(args) {
1033  return rgb2hwb(hsv2rgb(args))
1034}
1035
1036function hsv2cmyk(args) {
1037  return rgb2cmyk(hsv2rgb(args));
1038}
1039
1040function hsv2keyword(args) {
1041  return rgb2keyword(hsv2rgb(args));
1042}
1043
1044// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
1045function hwb2rgb(hwb) {
1046  var h = hwb[0] / 360,
1047      wh = hwb[1] / 100,
1048      bl = hwb[2] / 100,
1049      ratio = wh + bl,
1050      i, v, f, n;
1051
1052  // wh + bl cant be > 1
1053  if (ratio > 1) {
1054    wh /= ratio;
1055    bl /= ratio;
1056  }
1057
1058  i = Math.floor(6 * h);
1059  v = 1 - bl;
1060  f = 6 * h - i;
1061  if ((i & 0x01) != 0) {
1062    f = 1 - f;
1063  }
1064  n = wh + f * (v - wh);  // linear interpolation
1065
1066  switch (i) {
1067    default:
1068    case 6:
1069    case 0: r = v; g = n; b = wh; break;
1070    case 1: r = n; g = v; b = wh; break;
1071    case 2: r = wh; g = v; b = n; break;
1072    case 3: r = wh; g = n; b = v; break;
1073    case 4: r = n; g = wh; b = v; break;
1074    case 5: r = v; g = wh; b = n; break;
1075  }
1076
1077  return [r * 255, g * 255, b * 255];
1078}
1079
1080function hwb2hsl(args) {
1081  return rgb2hsl(hwb2rgb(args));
1082}
1083
1084function hwb2hsv(args) {
1085  return rgb2hsv(hwb2rgb(args));
1086}
1087
1088function hwb2cmyk(args) {
1089  return rgb2cmyk(hwb2rgb(args));
1090}
1091
1092function hwb2keyword(args) {
1093  return rgb2keyword(hwb2rgb(args));
1094}
1095
1096function cmyk2rgb(cmyk) {
1097  var c = cmyk[0] / 100,
1098      m = cmyk[1] / 100,
1099      y = cmyk[2] / 100,
1100      k = cmyk[3] / 100,
1101      r, g, b;
1102
1103  r = 1 - Math.min(1, c * (1 - k) + k);
1104  g = 1 - Math.min(1, m * (1 - k) + k);
1105  b = 1 - Math.min(1, y * (1 - k) + k);
1106  return [r * 255, g * 255, b * 255];
1107}
1108
1109function cmyk2hsl(args) {
1110  return rgb2hsl(cmyk2rgb(args));
1111}
1112
1113function cmyk2hsv(args) {
1114  return rgb2hsv(cmyk2rgb(args));
1115}
1116
1117function cmyk2hwb(args) {
1118  return rgb2hwb(cmyk2rgb(args));
1119}
1120
1121function cmyk2keyword(args) {
1122  return rgb2keyword(cmyk2rgb(args));
1123}
1124
1125
1126function xyz2rgb(xyz) {
1127  var x = xyz[0] / 100,
1128      y = xyz[1] / 100,
1129      z = xyz[2] / 100,
1130      r, g, b;
1131
1132  r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
1133  g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
1134  b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
1135
1136  // assume sRGB
1137  r = r > 0.0031308 ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
1138    : r = (r * 12.92);
1139
1140  g = g > 0.0031308 ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
1141    : g = (g * 12.92);
1142
1143  b = b > 0.0031308 ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
1144    : b = (b * 12.92);
1145
1146  r = Math.min(Math.max(0, r), 1);
1147  g = Math.min(Math.max(0, g), 1);
1148  b = Math.min(Math.max(0, b), 1);
1149
1150  return [r * 255, g * 255, b * 255];
1151}
1152
1153function xyz2lab(xyz) {
1154  var x = xyz[0],
1155      y = xyz[1],
1156      z = xyz[2],
1157      l, a, b;
1158
1159  x /= 95.047;
1160  y /= 100;
1161  z /= 108.883;
1162
1163  x = x > 0.008856 ? Math.pow(x, 1/3) : (7.787 * x) + (16 / 116);
1164  y = y > 0.008856 ? Math.pow(y, 1/3) : (7.787 * y) + (16 / 116);
1165  z = z > 0.008856 ? Math.pow(z, 1/3) : (7.787 * z) + (16 / 116);
1166
1167  l = (116 * y) - 16;
1168  a = 500 * (x - y);
1169  b = 200 * (y - z);
1170
1171  return [l, a, b];
1172}
1173
1174function xyz2lch(args) {
1175  return lab2lch(xyz2lab(args));
1176}
1177
1178function lab2xyz(lab) {
1179  var l = lab[0],
1180      a = lab[1],
1181      b = lab[2],
1182      x, y, z, y2;
1183
1184  if (l <= 8) {
1185    y = (l * 100) / 903.3;
1186    y2 = (7.787 * (y / 100)) + (16 / 116);
1187  } else {
1188    y = 100 * Math.pow((l + 16) / 116, 3);
1189    y2 = Math.pow(y / 100, 1/3);
1190  }
1191
1192  x = x / 95.047 <= 0.008856 ? x = (95.047 * ((a / 500) + y2 - (16 / 116))) / 7.787 : 95.047 * Math.pow((a / 500) + y2, 3);
1193
1194  z = z / 108.883 <= 0.008859 ? z = (108.883 * (y2 - (b / 200) - (16 / 116))) / 7.787 : 108.883 * Math.pow(y2 - (b / 200), 3);
1195
1196  return [x, y, z];
1197}
1198
1199function lab2lch(lab) {
1200  var l = lab[0],
1201      a = lab[1],
1202      b = lab[2],
1203      hr, h, c;
1204
1205  hr = Math.atan2(b, a);

1206  h = hr * 360 / 2 / Math.PI;
1207  if (h < 0) {
1208    h += 360;
1209  }
1210  c = Math.sqrt(a * a + b * b);
1211  return [l, c, h];
1212}
1213
1214function lab2rgb(args) {
1215  return xyz2rgb(lab2xyz(args));
1216}
1217
1218function lch2lab(lch) {
1219  var l = lch[0],
1220      c = lch[1],
1221      h = lch[2],
1222      a, b, hr;
1223
1224  hr = h / 360 * 2 * Math.PI;
1225  a = c * Math.cos(hr);
1226  b = c * Math.sin(hr);
1227  return [l, a, b];
1228}
1229
1230function lch2xyz(args) {
1231  return lab2xyz(lch2lab(args));
1232}
1233
1234function lch2rgb(args) {
1235  return lab2rgb(lch2lab(args));
1236}
1237
1238function keyword2rgb(keyword) {
1239  return cssKeywords[keyword];
1240}
1241
1242function keyword2hsl(args) {
1243  return rgb2hsl(keyword2rgb(args));
1244}
1245
1246function keyword2hsv(args) {
1247  return rgb2hsv(keyword2rgb(args));
1248}
1249
1250function keyword2hwb(args) {
1251  return rgb2hwb(keyword2rgb(args));
1252}
1253
1254function keyword2cmyk(args) {
1255  return rgb2cmyk(keyword2rgb(args));
1256}
1257
1258function keyword2lab(args) {
1259  return rgb2lab(keyword2rgb(args));
1260}
1261
1262function keyword2xyz(args) {
1263  return rgb2xyz(keyword2rgb(args));
1264}
1265
1266var cssKeywords = {
1267  aliceblue:  [240,248,255],
1268  antiquewhite: [250,235,215],
1269  aqua: [0,255,255],
1270  aquamarine: [127,255,212],
1271  azure:  [240,255,255],
1272  beige:  [245,245,220],
1273  bisque: [255,228,196],
1274  black:  [0,0,0],
1275  blanchedalmond: [255,235,205],
1276  blue: [0,0,255],
1277  blueviolet: [138,43,226],
1278  brown:  [165,42,42],
1279  burlywood:  [222,184,135],
1280  cadetblue:  [95,158,160],
1281  chartreuse: [127,255,0],
1282  chocolate:  [210,105,30],
1283  coral:  [255,127,80],
1284  cornflowerblue: [100,149,237],
1285  cornsilk: [255,248,220],
1286  crimson:  [220,20,60],
1287  cyan: [0,255,255],
1288  darkblue: [0,0,139],
1289  darkcyan: [0,139,139],
1290  darkgoldenrod:  [184,134,11],
1291  darkgray: [169,169,169],
1292  darkgreen:  [0,100,0],
1293  darkgrey: [169,169,169],
1294  darkkhaki:  [189,183,107],
1295  darkmagenta:  [139,0,139],
1296  darkolivegreen: [85,107,47],
1297  darkorange: [255,140,0],
1298  darkorchid: [153,50,204],
1299  darkred:  [139,0,0],
1300  darksalmon: [233,150,122],
1301  darkseagreen: [143,188,143],
1302  darkslateblue:  [72,61,139],
1303  darkslategray:  [47,79,79],
1304  darkslategrey:  [47,79,79],
1305  darkturquoise:  [0,206,209],
1306  darkviolet: [148,0,211],
1307  deeppink: [255,20,147],
1308  deepskyblue:  [0,191,255],
1309  dimgray:  [105,105,105],
1310  dimgrey:  [105,105,105],
1311  dodgerblue: [30,144,255],
1312  firebrick:  [178,34,34],
1313  floralwhite:  [255,250,240],
1314  forestgreen:  [34,139,34],
1315  fuchsia:  [255,0,255],
1316  gainsboro:  [220,220,220],
1317  ghostwhite: [248,248,255],
1318  gold: [255,215,0],
1319  goldenrod:  [218,165,32],
1320  gray: [128,128,128],
1321  green:  [0,128,0],
1322  greenyellow:  [173,255,47],
1323  grey: [128,128,128],
1324  honeydew: [240,255,240],
1325  hotpink:  [255,105,180],
1326  indianred:  [205,92,92],
1327  indigo: [75,0,130],
1328  ivory:  [255,255,240],
1329  khaki:  [240,230,140],
1330  lavender: [230,230,250],
1331  lavenderblush:  [255,240,245],
1332  lawngreen:  [124,252,0],
1333  lemonchiffon: [255,250,205],
1334  lightblue:  [173,216,230],
1335  lightcoral: [240,128,128],
1336  lightcyan:  [224,255,255],
1337  lightgoldenrodyellow: [250,250,210],
1338  lightgray:  [211,211,211],
1339  lightgreen: [144,238,144],
1340  lightgrey:  [211,211,211],
1341  lightpink:  [255,182,193],
1342  lightsalmon:  [255,160,122],
1343  lightseagreen:  [32,178,170],
1344  lightskyblue: [135,206,250],
1345  lightslategray: [119,136,153],
1346  lightslategrey: [119,136,153],
1347  lightsteelblue: [176,196,222],
1348  lightyellow:  [255,255,224],
1349  lime: [0,255,0],
1350  limegreen:  [50,205,50],
1351  linen:  [250,240,230],
1352  magenta:  [255,0,255],
1353  maroon: [128,0,0],
1354  mediumaquamarine: [102,205,170],
1355  mediumblue: [0,0,205],
1356  mediumorchid: [186,85,211],
1357  mediumpurple: [147,112,219],
1358  mediumseagreen: [60,179,113],
1359  mediumslateblue:  [123,104,238],
1360  mediumspringgreen:  [0,250,154],
1361  mediumturquoise:  [72,209,204],
1362  mediumvioletred:  [199,21,133],
1363  midnightblue: [25,25,112],
1364  mintcream:  [245,255,250],
1365  mistyrose:  [255,228,225],
1366  moccasin: [255,228,181],
1367  navajowhite:  [255,222,173],
1368  navy: [0,0,128],
1369  oldlace:  [253,245,230],
1370  olive:  [128,128,0],
1371  olivedrab:  [107,142,35],
1372  orange: [255,165,0],
1373  orangered:  [255,69,0],
1374  orchid: [218,112,214],
1375  palegoldenrod:  [238,232,170],
1376  palegreen:  [152,251,152],
1377  paleturquoise:  [175,238,238],
1378  palevioletred:  [219,112,147],
1379  papayawhip: [255,239,213],
1380  peachpuff:  [255,218,185],
1381  peru: [205,133,63],
1382  pink: [255,192,203],
1383  plum: [221,160,221],
1384  powderblue: [176,224,230],
1385  purple: [128,0,128],
1386  rebeccapurple: [102, 51, 153],
1387  red:  [255,0,0],
1388  rosybrown:  [188,143,143],
1389  royalblue:  [65,105,225],
1390  saddlebrown:  [139,69,19],
1391  salmon: [250,128,114],
1392  sandybrown: [244,164,96],

1393  seagreen: [46,139,87],
1394  seashell: [255,245,238],
1395  sienna: [160,82,45],
1396  silver: [192,192,192],
1397  skyblue:  [135,206,235],
1398  slateblue:  [106,90,205],
1399  slategray:  [112,128,144],
1400  slategrey:  [112,128,144],
1401  snow: [255,250,250],
1402  springgreen:  [0,255,127],
1403  steelblue:  [70,130,180],
1404  tan:  [210,180,140],
1405  teal: [0,128,128],
1406  thistle:  [216,191,216],
1407  tomato: [255,99,71],
1408  turquoise:  [64,224,208],
1409  violet: [238,130,238],
1410  wheat:  [245,222,179],
1411  white:  [255,255,255],
1412  whitesmoke: [245,245,245],
1413  yellow: [255,255,0],
1414  yellowgreen:  [154,205,50]
1415};
1416
1417var reverseKeywords = {};
1418for (var key in cssKeywords) {
1419  reverseKeywords[JSON.stringify(cssKeywords[key])] = key;
1420}
1421
1422},{}],5:[function(require,module,exports){
1423var conversions = require(4);
1424
1425var convert = function() {
1426   return new Converter();
1427}
1428
1429for (var func in conversions) {
1430  // export Raw versions
1431  convert[func + "Raw"] =  (function(func) {
1432    // accept array or plain args
1433    return function(arg) {
1434      if (typeof arg == "number")
1435        arg = Array.prototype.slice.call(arguments);
1436      return conversions[func](arg);
1437    }
1438  })(func);
1439
1440  var pair = /(\w+)2(\w+)/.exec(func),
1441      from = pair[1],
1442      to = pair[2];
1443
1444  // export rgb2hsl and ["rgb"]["hsl"]
1445  convert[from] = convert[from] || {};
1446
1447  convert[from][to] = convert[func] = (function(func) { 
1448    return function(arg) {
1449      if (typeof arg == "number")
1450        arg = Array.prototype.slice.call(arguments);
1451      
1452      var val = conversions[func](arg);
1453      if (typeof val == "string" || val === undefined)
1454        return val; // keyword
1455
1456      for (var i = 0; i < val.length; i++)
1457        val[i] = Math.round(val[i]);
1458      return val;
1459    }
1460  })(func);
1461}
1462
1463
1464/* Converter does lazy conversion and caching */
1465var Converter = function() {
1466   this.convs = {};
1467};
1468
1469/* Either get the values for a space or
1470  set the values for a space, depending on args */
1471Converter.prototype.routeSpace = function(space, args) {
1472   var values = args[0];
1473   if (values === undefined) {
1474      // color.rgb()
1475      return this.getValues(space);
1476   }
1477   // color.rgb(10, 10, 10)
1478   if (typeof values == "number") {
1479      values = Array.prototype.slice.call(args);        
1480   }
1481
1482   return this.setValues(space, values);
1483};
1484  
1485/* Set the values for a space, invalidating cache */
1486Converter.prototype.setValues = function(space, values) {
1487   this.space = space;
1488   this.convs = {};
1489   this.convs[space] = values;
1490   return this;
1491};
1492
1493/* Get the values for a space. If there's already
1494  a conversion for the space, fetch it, otherwise
1495  compute it */
1496Converter.prototype.getValues = function(space) {
1497   var vals = this.convs[space];
1498   if (!vals) {
1499      var fspace = this.space,
1500          from = this.convs[fspace];
1501      vals = convert[fspace][space](from);
1502
1503      this.convs[space] = vals;
1504   }
1505  return vals;
1506};
1507
1508["rgb", "hsl", "hsv", "cmyk", "keyword"].forEach(function(space) {
1509   Converter.prototype[space] = function(vals) {
1510      return this.routeSpace(space, arguments);
1511   }
1512});
1513
1514module.exports = convert;
1515},{"4":4}],6:[function(require,module,exports){
1516'use strict'
1517
1518module.exports = {
1519	"aliceblue": [240, 248, 255],
1520	"antiquewhite": [250, 235, 215],
1521	"aqua": [0, 255, 255],
1522	"aquamarine": [127, 255, 212],
1523	"azure": [240, 255, 255],
1524	"beige": [245, 245, 220],
1525	"bisque": [255, 228, 196],
1526	"black": [0, 0, 0],
1527	"blanchedalmond": [255, 235, 205],
1528	"blue": [0, 0, 255],
1529	"blueviolet": [138, 43, 226],
1530	"brown": [165, 42, 42],
1531	"burlywood": [222, 184, 135],
1532	"cadetblue": [95, 158, 160],
1533	"chartreuse": [127, 255, 0],
1534	"chocolate": [210, 105, 30],
1535	"coral": [255, 127, 80],
1536	"cornflowerblue": [100, 149, 237],
1537	"cornsilk": [255, 248, 220],
1538	"crimson": [220, 20, 60],
1539	"cyan": [0, 255, 255],
1540	"darkblue": [0, 0, 139],
1541	"darkcyan": [0, 139, 139],
1542	"darkgoldenrod": [184, 134, 11],
1543	"darkgray": [169, 169, 169],
1544	"darkgreen": [0, 100, 0],
1545	"darkgrey": [169, 169, 169],
1546	"darkkhaki": [189, 183, 107],
1547	"darkmagenta": [139, 0, 139],
1548	"darkolivegreen": [85, 107, 47],
1549	"darkorange": [255, 140, 0],
1550	"darkorchid": [153, 50, 204],
1551	"darkred": [139, 0, 0],
1552	"darksalmon": [233, 150, 122],
1553	"darkseagreen": [143, 188, 143],
1554	"darkslateblue": [72, 61, 139],
1555	"darkslategray": [47, 79, 79],
1556	"darkslategrey": [47, 79, 79],

1557	"darkturquoise": [0, 206, 209],
1558	"darkviolet": [148, 0, 211],
1559	"deeppink": [255, 20, 147],
1560	"deepskyblue": [0, 191, 255],
1561	"dimgray": [105, 105, 105],
1562	"dimgrey": [105, 105, 105],
1563	"dodgerblue": [30, 144, 255],
1564	"firebrick": [178, 34, 34],
1565	"floralwhite": [255, 250, 240],
1566	"forestgreen": [34, 139, 34],
1567	"fuchsia": [255, 0, 255],
1568	"gainsboro": [220, 220, 220],
1569	"ghostwhite": [248, 248, 255],
1570	"gold": [255, 215, 0],
1571	"goldenrod": [218, 165, 32],
1572	"gray": [128, 128, 128],
1573	"green": [0, 128, 0],
1574	"greenyellow": [173, 255, 47],
1575	"grey": [128, 128, 128],
1576	"honeydew": [240, 255, 240],
1577	"hotpink": [255, 105, 180],
1578	"indianred": [205, 92, 92],
1579	"indigo": [75, 0, 130],
1580	"ivory": [255, 255, 240],
1581	"khaki": [240, 230, 140],
1582	"lavender": [230, 230, 250],
1583	"lavenderblush": [255, 240, 245],
1584	"lawngreen": [124, 252, 0],
1585	"lemonchiffon": [255, 250, 205],
1586	"lightblue": [173, 216, 230],
1587	"lightcoral": [240, 128, 128],
1588	"lightcyan": [224, 255, 255],
1589	"lightgoldenrodyellow": [250, 250, 210],
1590	"lightgray": [211, 211, 211],
1591	"lightgreen": [144, 238, 144],
1592	"lightgrey": [211, 211, 211],
1593	"lightpink": [255, 182, 193],
1594	"lightsalmon": [255, 160, 122],
1595	"lightseagreen": [32, 178, 170],
1596	"lightskyblue": [135, 206, 250],
1597	"lightslategray": [119, 136, 153],
1598	"lightslategrey": [119, 136, 153],
1599	"lightsteelblue": [176, 196, 222],
1600	"lightyellow": [255, 255, 224],
1601	"lime": [0, 255, 0],
1602	"limegreen": [50, 205, 50],
1603	"linen": [250, 240, 230],
1604	"magenta": [255, 0, 255],
1605	"maroon": [128, 0, 0],
1606	"mediumaquamarine": [102, 205, 170],
1607	"mediumblue": [0, 0, 205],
1608	"mediumorchid": [186, 85, 211],
1609	"mediumpurple": [147, 112, 219],
1610	"mediumseagreen": [60, 179, 113],
1611	"mediumslateblue": [123, 104, 238],
1612	"mediumspringgreen": [0, 250, 154],
1613	"mediumturquoise": [72, 209, 204],
1614	"mediumvioletred": [199, 21, 133],
1615	"midnightblue": [25, 25, 112],
1616	"mintcream": [245, 255, 250],
1617	"mistyrose": [255, 228, 225],
1618	"moccasin": [255, 228, 181],
1619	"navajowhite": [255, 222, 173],
1620	"navy": [0, 0, 128],
1621	"oldlace": [253, 245, 230],
1622	"olive": [128, 128, 0],
1623	"olivedrab": [107, 142, 35],
1624	"orange": [255, 165, 0],
1625	"orangered": [255, 69, 0],
1626	"orchid": [218, 112, 214],
1627	"palegoldenrod": [238, 232, 170],
1628	"palegreen": [152, 251, 152],
1629	"paleturquoise": [175, 238, 238],
1630	"palevioletred": [219, 112, 147],
1631	"papayawhip": [255, 239, 213],
1632	"peachpuff": [255, 218, 185],
1633	"peru": [205, 133, 63],
1634	"pink": [255, 192, 203],
1635	"plum": [221, 160, 221],
1636	"powderblue": [176, 224, 230],
1637	"purple": [128, 0, 128],
1638	"rebeccapurple": [102, 51, 153],
1639	"red": [255, 0, 0],
1640	"rosybrown": [188, 143, 143],
1641	"royalblue": [65, 105, 225],
1642	"saddlebrown": [139, 69, 19],
1643	"salmon": [250, 128, 114],
1644	"sandybrown": [244, 164, 96],
1645	"seagreen": [46, 139, 87],
1646	"seashell": [255, 245, 238],
1647	"sienna": [160, 82, 45],
1648	"silver": [192, 192, 192],
1649	"skyblue": [135, 206, 235],
1650	"slateblue": [106, 90, 205],
1651	"slategray": [112, 128, 144],
1652	"slategrey": [112, 128, 144],
1653	"snow": [255, 250, 250],
1654	"springgreen": [0, 255, 127],
1655	"steelblue": [70, 130, 180],
1656	"tan": [210, 180, 140],
1657	"teal": [0, 128, 128],
1658	"thistle": [216, 191, 216],
1659	"tomato": [255, 99, 71],
1660	"turquoise": [64, 224, 208],
1661	"violet": [238, 130, 238],
1662	"wheat": [245, 222, 179],
1663	"white": [255, 255, 255],
1664	"whitesmoke": [245, 245, 245],
1665	"yellow": [255, 255, 0],
1666	"yellowgreen": [154, 205, 50]
1667};
1668
1669},{}],7:[function(require,module,exports){
1670/**
1671 * @namespace Chart
1672 */
1673var Chart = require(29)();
1674
1675Chart.helpers = require(45);
1676
1677// @todo dispatch these helpers into appropriated helpers/helpers.* file and write unit tests!
1678require(27)(Chart);
1679
1680Chart.defaults = require(25);
1681Chart.Element = require(26);
1682Chart.elements = require(40);
1683Chart.Interaction = require(28);
1684Chart.layouts = require(30);
1685Chart.platform = require(48);
1686Chart.plugins = require(31);
1687Chart.Ticks = require(34);
1688
1689require(22)(Chart);
1690require(23)(Chart);
1691require(24)(Chart);
1692require(33)(Chart);
1693require(32)(Chart);
1694require(35)(Chart);
1695
1696require(55)(Chart);
1697require(53)(Chart);
1698require(54)(Chart);
1699require(56)(Chart);
1700require(57)(Chart);
1701require(58)(Chart);
1702
1703// Controllers must be loaded after elements
1704// See Chart.core.datasetController.dataElementType
1705require(15)(Chart);
1706require(16)(Chart);
1707require(17)(Chart);
1708require(18)(Chart);
1709require(19)(Chart);
1710require(20)(Chart);
1711require(21)(Chart);
1712
1713require(8)(Chart);
1714require(9)(Chart);
1715require(10)(Chart);
1716require(11)(Chart);
1717require(12)(Chart);
1718require(13)(Chart);
1719require(14)(Chart);
1720
1721// Loading built-it plugins
1722var plugins = require(49);
1723for (var k in plugins) {
1724	if (plugins.hasOwnProperty(k)) {
1725		Chart.plugins.register(plugins[k]);
1726	}
1727}
1728
1729Chart.platform.initialize();
1730
1731module.exports = Chart;
1732if (typeof window !== 'undefined') {
1733	window.Chart = Chart;
1734}
1735
1736// DEPRECATIONS
1737
1738/**
1739 * Provided for backward compatibility, not available anymore
1740 * @namespace Chart.Legend
1741 * @deprecated since version 2.1.5
1742 * @todo remove at version 3
1743 * @private
1744 */
1745Chart.Legend = plugins.legend._element;
1746
1747/**
1748 * Provided for backward compatibility, not available anymore
1749 * @namespace Chart.Title
1750 * @deprecated since version 2.1.5
1751 * @todo remove at version 3
1752 * @private
1753 */
1754Chart.Title = plugins.title._element;
1755
1756/**
1757 * Provided for backward compatibility, use Chart.plugins instead

1758 * @namespace Chart.pluginService
1759 * @deprecated since version 2.1.5
1760 * @todo remove at version 3
1761 * @private
1762 */
1763Chart.pluginService = Chart.plugins;
1764
1765/**
1766 * Provided for backward compatibility, inheriting from Chart.PlugingBase has no
1767 * effect, instead simply create/register plugins via plain JavaScript objects.
1768 * @interface Chart.PluginBase
1769 * @deprecated since version 2.5.0
1770 * @todo remove at version 3
1771 * @private
1772 */
1773Chart.PluginBase = Chart.Element.extend({});
1774
1775/**
1776 * Provided for backward compatibility, use Chart.helpers.canvas instead.
1777 * @namespace Chart.canvasHelpers
1778 * @deprecated since version 2.6.0
1779 * @todo remove at version 3
1780 * @private
1781 */
1782Chart.canvasHelpers = Chart.helpers.canvas;
1783
1784/**
1785 * Provided for backward compatibility, use Chart.layouts instead.
1786 * @namespace Chart.layoutService
1787 * @deprecated since version 2.8.0
1788 * @todo remove at version 3
1789 * @private
1790 */
1791Chart.layoutService = Chart.layouts;
1792
1793},{"10":10,"11":11,"12":12,"13":13,"14":14,"15":15,"16":16,"17":17,"18":18,"19":19,"20":20,"21":21,"22":22,"23":23,"24":24,"25":25,"26":26,"27":27,"28":28,"29":29,"30":30,"31":31,"32":32,"33":33,"34":34,"35":35,"40":40,"45":45,"48":48,"49":49,"53":53,"54":54,"55":55,"56":56,"57":57,"58":58,"8":8,"9":9}],8:[function(require,module,exports){
1794'use strict';
1795
1796module.exports = function(Chart) {
1797
1798	Chart.Bar = function(context, config) {
1799		config.type = 'bar';
1800
1801		return new Chart(context, config);
1802	};
1803
1804};
1805
1806},{}],9:[function(require,module,exports){
1807'use strict';
1808
1809module.exports = function(Chart) {
1810
1811	Chart.Bubble = function(context, config) {
1812		config.type = 'bubble';
1813		return new Chart(context, config);
1814	};
1815
1816};
1817
1818},{}],10:[function(require,module,exports){
1819'use strict';
1820
1821module.exports = function(Chart) {
1822
1823	Chart.Doughnut = function(context, config) {
1824		config.type = 'doughnut';
1825
1826		return new Chart(context, config);
1827	};
1828
1829};
1830
1831},{}],11:[function(require,module,exports){
1832'use strict';
1833
1834module.exports = function(Chart) {
1835
1836	Chart.Line = function(context, config) {
1837		config.type = 'line';
1838
1839		return new Chart(context, config);
1840	};
1841
1842};
1843
1844},{}],12:[function(require,module,exports){
1845'use strict';
1846
1847module.exports = function(Chart) {
1848
1849	Chart.PolarArea = function(context, config) {
1850		config.type = 'polarArea';
1851
1852		return new Chart(context, config);
1853	};
1854
1855};
1856
1857},{}],13:[function(require,module,exports){
1858'use strict';
1859
1860module.exports = function(Chart) {
1861
1862	Chart.Radar = function(context, config) {
1863		config.type = 'radar';
1864
1865		return new Chart(context, config);
1866	};
1867
1868};
1869
1870},{}],14:[function(require,module,exports){
1871'use strict';
1872
1873module.exports = function(Chart) {
1874	Chart.Scatter = function(context, config) {
1875		config.type = 'scatter';
1876		return new Chart(context, config);
1877	};
1878};
1879
1880},{}],15:[function(require,module,exports){
1881'use strict';
1882
1883var defaults = require(25);
1884var elements = require(40);
1885var helpers = require(45);
1886
1887defaults._set('bar', {
1888	hover: {
1889		mode: 'label'
1890	},
1891
1892	scales: {
1893		xAxes: [{
1894			type: 'category',
1895
1896			// Specific to Bar Controller
1897			categoryPercentage: 0.8,
1898			barPercentage: 0.9,
1899
1900			// offset settings
1901			offset: true,
1902
1903			// grid line settings
1904			gridLines: {
1905				offsetGridLines: true
1906			}
1907		}],
1908
1909		yAxes: [{
1910			type: 'linear'
1911		}]
1912	}
1913});
1914
1915defaults._set('horizontalBar', {
1916	hover: {
1917		mode: 'index',
1918		axis: 'y'
1919	},
1920
1921	scales: {
1922		xAxes: [{
1923			type: 'linear',
1924			position: 'bottom'
1925		}],
1926
1927		yAxes: [{
1928			position: 'left',
1929			type: 'category',
1930
1931			// Specific to Horizontal Bar Controller
1932			categoryPercentage: 0.8,
1933			barPercentage: 0.9,
1934
1935			// offset settings
1936			offset: true,
1937
1938			// grid line settings
1939			gridLines: {
1940				offsetGridLines: true
1941			}
1942		}]
1943	},
1944
1945	elements: {
1946		rectangle: {
1947			borderSkipped: 'left'
1948		}
1949	},
1950
1951	tooltips: {
1952		callbacks: {
1953			title: function(item, data) {
1954				// Pick first xLabel for now
1955				var title = '';
1956
1957				if (item.length > 0) {
1958					if (item[0].yLabel) {
1959						title = item[0].yLabel;
1960					} else if (data.labels.length > 0 && item[0].index < data.labels.length) {
1961						title = data.labels[item[0].index];
1962					}
1963				}
1964
1965				return title;
1966			},
1967
1968			label: function(item, data) {
1969				var datasetLabel = data.datasets[item.datasetIndex].label || '';
1970				return datasetLabel + ': ' + item.xLabel;
1971			}
1972		},
1973		mode: 'index',
1974		axis: 'y'
1975	}
1976});
1977
1978/**
1979 * Computes the "optimal" sample size to maintain bars equally sized while preventing overlap.
1980 * @private
1981 */
1982function computeMinSampleSize(scale, pixels) {
1983	var min = scale.isHorizontal() ? scale.width : scale.height;
1984	var ticks = scale.getTicks();
1985	var prev, curr, i, ilen;
1986
1987	for (i = 1, ilen = pixels.length; i < ilen; ++i) {
1988		min = Math.min(min, pixels[i] - pixels[i - 1]);
1989	}
1990
1991	for (i = 0, ilen = ticks.length; i < ilen; ++i) {
1992		curr = scale.getPixelForTick(i);
1993		min = i > 0 ? Math.min(min, curr - prev) : min;
1994		prev = curr;
1995	}
1996
1997	return min;
1998}
1999
2000/**
2001 * Computes an "ideal" category based on the absolute bar thickness or, if undefined or null,
2002 * uses the smallest interval (see computeMinSampleSize) that prevents bar overlapping. This
2003 * mode currently always generates bars equally sized (until we introduce scriptable options?).
2004 * @private
2005 */
2006function computeFitCategoryTraits(index, ruler, options) {
2007	var thickness = options.barThickness;
2008	var count = ruler.stackCount;
2009	var curr = ruler.pixels[index];
2010	var size, ratio;
2011
2012	if (helpers.isNullOrUndef(thickness)) {
2013		size = ruler.min * options.categoryPercentage;
2014		ratio = options.barPercentage;
2015	} else {
2016		// When bar thickness is enforced, category and bar percentages are ignored.
2017		// Note(SB): we could add support for relative bar thickness (e.g. barThickness: '50%')
2018		// and deprecate barPercentage since this value is ignored when thickness is absolute.
2019		size = thickness * count;
2020		ratio = 1;
2021	}
2022
2023	return {
2024		chunk: size / count,
2025		ratio: ratio,
2026		start: curr - (size / 2)
2027	};
2028}
2029
2030/**
2031 * Computes an "optimal" category that globally arranges bars side by side (no gap when
2032 * percentage options are 1), based on the previous and following categories. This mode
2033 * generates bars with different widths when data are not evenly spaced.
2034 * @private
2035 */
2036function computeFlexCategoryTraits(index, ruler, options) {
2037	var pixels = ruler.pixels;
2038	var curr = pixels[index];
2039	var prev = index > 0 ? pixels[index - 1] : null;
2040	var next = index < pixels.length - 1 ? pixels[index + 1] : null;
2041	var percent = options.categoryPercentage;
2042	var start, size;
2043
2044	if (prev === null) {
2045		// first data: its size is double based on the next point or,
2046		// if it's also the last data, we use the scale end extremity.
2047		prev = curr - (next === null ? ruler.end - curr : next - curr);
2048	}
2049
2050	if (next === null) {
2051		// last data: its size is also double based on the previous point.
2052		next = curr + curr - prev;
2053	}
2054
2055	start = curr - ((curr - prev) / 2) * percent;
2056	size = ((next - prev) / 2) * percent;
2057
2058	return {
2059		chunk: size / ruler.stackCount,
2060		ratio: options.barPercentage,
2061		start: start
2062	};
2063}
2064
2065module.exports = function(Chart) {
2066
2067	Chart.controllers.bar = Chart.DatasetController.extend({
2068
2069		dataElementType: elements.Rectangle,
2070
2071		initialize: function() {
2072			var me = this;
2073			var meta;
2074
2075			Chart.DatasetController.prototype.initialize.apply(me, arguments);
2076
2077			meta = me.getMeta();
2078			meta.stack = me.getDataset().stack;
2079			meta.bar = true;
2080		},
2081
2082		update: function(reset) {
2083			var me = this;
2084			var rects = me.getMeta().data;
2085			var i, ilen;
2086
2087			me._ruler = me.getRuler();
2088
2089			for (i = 0, ilen = rects.length; i < ilen; ++i) {
2090				me.updateElement(rects[i], i, reset);
2091			}
2092		},
2093
2094		updateElement: function(rectangle, index, reset) {
2095			var me = this;
2096			var chart = me.chart;
2097			var meta = me.getMeta();
2098			var dataset = me.getDataset();
2099			var custom = rectangle.custom || {};
2100			var rectangleOptions = chart.options.elements.rectangle;
2101
2102			rectangle._xScale = me.getScaleForId(meta.xAxisID);
2103			rectangle._yScale = me.getScaleForId(meta.yAxisID);
2104			rectangle._datasetIndex = me.index;
2105			rectangle._index = index;
2106
2107			rectangle._model = {
2108				datasetLabel: dataset.label,
2109				label: chart.data.labels[index],
2110				borderSkipped: custom.borderSkipped ? custom.borderSkipped : rectangleOptions.borderSkipped,
2111				backgroundColor: custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.backgroundColor, index, rectangleOptions.backgroundColor),
2112				borderColor: custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.borderColor, index, rectangleOptions.borderColor),
2113				borderWidth: custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.borderWidth, index, rectangleOptions.borderWidth)
2114			};
2115
2116			me.updateElementGeometry(rectangle, index, reset);
2117
2118			rectangle.pivot();
2119		},
2120
2121		/**
2122		 * @private
2123		 */
2124		updateElementGeometry: function(rectangle, index, reset) {
2125			var me = this;
2126			var model = rectangle._model;
2127			var vscale = me.getValueScale();
2128			var base = vscale.getBasePixel();
2129			var horizontal = vscale.isHorizontal();
2130			var ruler = me._ruler || me.getRuler();
2131			var vpixels = me.calculateBarValuePixels(me.index, index);
2132			var ipixels = me.calculateBarIndexPixels(me.index, index, ruler);
2133
2134			model.horizontal = horizontal;
2135			model.base = reset ? base : vpixels.base;
2136			model.x = horizontal ? reset ? base : vpixels.head : ipixels.center;
2137			model.y = horizontal ? ipixels.center : reset ? base : vpixels.head;
2138			model.height = horizontal ? ipixels.size : undefined;
2139			model.width = horizontal ? undefined : ipixels.size;
2140		},
2141
2142		/**
2143		 * @private
2144		 */
2145		getValueScaleId: function() {
2146			return this.getMeta().yAxisID;
2147		},
2148
2149		/**
2150		 * @private
2151		 */
2152		getIndexScaleId: function() {
2153			return this.getMeta().xAxisID;
2154		},
2155
2156		/**
2157		 * @private
2158		 */
2159		getValueScale: function() {

2160			return this.getScaleForId(this.getValueScaleId());
2161		},
2162
2163		/**
2164		 * @private
2165		 */
2166		getIndexScale: function() {
2167			return this.getScaleForId(this.getIndexScaleId());
2168		},
2169
2170		/**
2171		 * Returns the stacks based on groups and bar visibility.
2172		 * @param {Number} [last] - The dataset index
2173		 * @returns {Array} The stack list
2174		 * @private
2175		 */
2176		_getStacks: function(last) {
2177			var me = this;
2178			var chart = me.chart;
2179			var scale = me.getIndexScale();
2180			var stacked = scale.options.stacked;
2181			var ilen = last === undefined ? chart.data.datasets.length : last + 1;
2182			var stacks = [];
2183			var i, meta;
2184
2185			for (i = 0; i < ilen; ++i) {
2186				meta = chart.getDatasetMeta(i);
2187				if (meta.bar && chart.isDatasetVisible(i) &&
2188					(stacked === false ||
2189					(stacked === true && stacks.indexOf(meta.stack) === -1) ||
2190					(stacked === undefined && (meta.stack === undefined || stacks.indexOf(meta.stack) === -1)))) {
2191					stacks.push(meta.stack);
2192				}
2193			}
2194
2195			return stacks;
2196		},
2197
2198		/**
2199		 * Returns the effective number of stacks based on groups and bar visibility.
2200		 * @private
2201		 */
2202		getStackCount: function() {
2203			return this._getStacks().length;
2204		},
2205
2206		/**
2207		 * Returns the stack index for the given dataset based on groups and bar visibility.
2208		 * @param {Number} [datasetIndex] - The dataset index
2209		 * @param {String} [name] - The stack name to find
2210		 * @returns {Number} The stack index
2211		 * @private
2212		 */
2213		getStackIndex: function(datasetIndex, name) {
2214			var stacks = this._getStacks(datasetIndex);
2215			var index = (name !== undefined)
2216				? stacks.indexOf(name)
2217				: -1; // indexOf returns -1 if element is not present
2218
2219			return (index === -1)
2220				? stacks.length - 1
2221				: index;
2222		},
2223
2224		/**
2225		 * @private
2226		 */
2227		getRuler: function() {
2228			var me = this;
2229			var scale = me.getIndexScale();
2230			var stackCount = me.getStackCount();
2231			var datasetIndex = me.index;
2232			var isHorizontal = scale.isHorizontal();
2233			var start = isHorizontal ? scale.left : scale.top;
2234			var end = start + (isHorizontal ? scale.width : scale.height);
2235			var pixels = [];
2236			var i, ilen, min;
2237
2238			for (i = 0, ilen = me.getMeta().data.length; i < ilen; ++i) {
2239				pixels.push(scale.getPixelForValue(null, i, datasetIndex));
2240			}
2241
2242			min = helpers.isNullOrUndef(scale.options.barThickness)
2243				? computeMinSampleSize(scale, pixels)
2244				: -1;
2245
2246			return {
2247				min: min,
2248				pixels: pixels,
2249				start: start,
2250				end: end,
2251				stackCount: stackCount,
2252				scale: scale
2253			};
2254		},
2255
2256		/**
2257		 * Note: pixel values are not clamped to the scale area.
2258		 * @private
2259		 */
2260		calculateBarValuePixels: function(datasetIndex, index) {
2261			var me = this;
2262			var chart = me.chart;
2263			var meta = me.getMeta();
2264			var scale = me.getValueScale();
2265			var datasets = chart.data.datasets;
2266			var value = scale.getRightValue(datasets[datasetIndex].data[index]);
2267			var stacked = scale.options.stacked;
2268			var stack = meta.stack;
2269			var start = 0;
2270			var i, imeta, ivalue, base, head, size;
2271
2272			if (stacked || (stacked === undefined && stack !== undefined)) {
2273				for (i = 0; i < datasetIndex; ++i) {
2274					imeta = chart.getDatasetMeta(i);
2275
2276					if (imeta.bar &&
2277						imeta.stack === stack &&
2278						imeta.controller.getValueScaleId() === scale.id &&
2279						chart.isDatasetVisible(i)) {
2280
2281						ivalue = scale.getRightValue(datasets[i].data[index]);
2282						if ((value < 0 && ivalue < 0) || (value >= 0 && ivalue > 0)) {
2283							start += ivalue;
2284						}
2285					}
2286				}
2287			}
2288
2289			base = scale.getPixelForValue(start);
2290			head = scale.getPixelForValue(start + value);
2291			size = (head - base) / 2;
2292
2293			return {
2294				size: size,
2295				base: base,
2296				head: head,
2297				center: head + size / 2
2298			};
2299		},
2300
2301		/**
2302		 * @private
2303		 */
2304		calculateBarIndexPixels: function(datasetIndex, index, ruler) {
2305			var me = this;
2306			var options = ruler.scale.options;
2307			var range = options.barThickness === 'flex'
2308				? computeFlexCategoryTraits(index, ruler, options)
2309				: computeFitCategoryTraits(index, ruler, options);
2310
2311			var stackIndex = me.getStackIndex(datasetIndex, me.getMeta().stack);
2312			var center = range.start + (range.chunk * stackIndex) + (range.chunk / 2);
2313			var size = Math.min(
2314				helpers.valueOrDefault(options.maxBarThickness, Infinity),
2315				range.chunk * range.ratio);
2316
2317			return {
2318				base: center - size / 2,
2319				head: center + size / 2,
2320				center: center,
2321				size: size
2322			};
2323		},
2324
2325		draw: function() {
2326			var me = this;
2327			var chart = me.chart;
2328			var scale = me.getValueScale();
2329			var rects = me.getMeta().data;
2330			var dataset = me.getDataset();
2331			var ilen = rects.length;
2332			var i = 0;
2333
2334			helpers.canvas.clipArea(chart.ctx, chart.chartArea);
2335
2336			for (; i < ilen; ++i) {
2337				if (!isNaN(scale.getRightValue(dataset.data[i]))) {
2338					rects[i].draw();
2339				}
2340			}
2341
2342			helpers.canvas.unclipArea(chart.ctx);
2343		},
2344
2345		setHoverStyle: function(rectangle) {
2346			var dataset = this.chart.data.datasets[rectangle._datasetIndex];
2347			var index = rectangle._index;
2348			var custom = rectangle.custom || {};
2349			var model = rectangle._model;
2350

2351			model.backgroundColor = custom.hoverBackgroundColor ? custom.hoverBackgroundColor : helpers.valueAtIndexOrDefault(dataset.hoverBackgroundColor, index, helpers.getHoverColor(model.backgroundColor));
2352			model.borderColor = custom.hoverBorderColor ? custom.hoverBorderColor : helpers.valueAtIndexOrDefault(dataset.hoverBorderColor, index, helpers.getHoverColor(model.borderColor));
2353			model.borderWidth = custom.hoverBorderWidth ? custom.hoverBorderWidth : helpers.valueAtIndexOrDefault(dataset.hoverBorderWidth, index, model.borderWidth);
2354		},
2355
2356		removeHoverStyle: function(rectangle) {
2357			var dataset = this.chart.data.datasets[rectangle._datasetIndex];
2358			var index = rectangle._index;
2359			var custom = rectangle.custom || {};
2360			var model = rectangle._model;
2361			var rectangleElementOptions = this.chart.options.elements.rectangle;
2362
2363			model.backgroundColor = custom.backgroundColor ? custom.backgroundColor : helpers.valueAtIndexOrDefault(dataset.backgroundColor, index, rectangleElementOptions.backgroundColor);
2364			model.borderColor = custom.borderColor ? custom.borderColor : helpers.valueAtIndexOrDefault(dataset.borderColor, index, rectangleElementOptions.borderColor);
2365			model.borderWidth = custom.borderWidth ? custom.borderWidth : helpers.valueAtIndexOrDefault(dataset.borderWidth, index, rectangleElementOptions.borderWidth);
2366		}
2367	});
2368
2369	Chart.controllers.horizontalBar = Chart.controllers.bar.extend({
2370		/**
2371		 * @private
2372		 */
2373		getValueScaleId: function() {
2374			return this.getMeta().xAxisID;
2375		},
2376
2377		/**
2378		 * @private
2379		 */
2380		getIndexScaleId: function() {
2381			return this.getMeta().yAxisID;
2382		}
2383	});
2384};
2385
2386},{"25":25,"40":40,"45":45}],16:[function(require,module,exports){
2387'use strict';
2388
2389var defaults = require(25);
2390var elements = require(40);
2391var helpers = require(45);
2392
2393defaults._set('bubble', {
2394	hover: {
2395		mode: 'single'
2396	},
2397
2398	scales: {
2399		xAxes: [{
2400			type: 'linear', // bubble should probably use a linear scale by default
2401			position: 'bottom',
2402			id: 'x-axis-0' // need an ID so datasets can reference the scale
2403		}],
2404		yAxes: [{
2405			type: 'linear',
2406			position: 'left',
2407			id: 'y-axis-0'
2408		}]
2409	},
2410
2411	tooltips: {
2412		callbacks: {
2413			title: function() {
2414				// Title doesn't make sense for scatter since we format the data as a point
2415				return '';
2416			},
2417			label: function(item, data) {
2418				var datasetLabel = data.datasets[item.datasetIndex].label || '';
2419				var dataPoint = data.datasets[item.datasetIndex].data[item.index];
2420				return datasetLabel + ': (' + item.xLabel + ', ' + item.yLabel + ', ' + dataPoint.r + ')';
2421			}
2422		}
2423	}
2424});
2425
2426
2427module.exports = function(Chart) {
2428
2429	Chart.controllers.bubble = Chart.DatasetController.extend({
2430		/**
2431		 * @protected
2432		 */
2433		dataElementType: elements.Point,
2434
2435		/**
2436		 * @protected
2437		 */
2438		update: function(reset) {
2439			var me = this;
2440			var meta = me.getMeta();
2441			var points = meta.data;
2442
2443			// Update Points
2444			helpers.each(points, function(point, index) {
2445				me.updateElement(point, index, reset);
2446			});
2447		},
2448
2449		/**
2450		 * @protected
2451		 */
2452		updateElement: function(point, index, reset) {
2453			var me = this;
2454			var meta = me.getMeta();
2455			var custom = point.custom || {};
2456			var xScale = me.getScaleForId(meta.xAxisID);
2457			var yScale = me.getScaleForId(meta.yAxisID);
2458			var options = me._resolveElementOptions(point, index);
2459			var data = me.getDataset().data[index];
2460			var dsIndex = me.index;
2461
2462			var x = reset ? xScale.getPixelForDecimal(0.5) : xScale.getPixelForValue(typeof data === 'object' ? data : NaN, index, dsIndex);
2463			var y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(data, index, dsIndex);
2464
2465			point._xScale = xScale;
2466			point._yScale = yScale;
2467			point._options = options;
2468			point._datasetIndex = dsIndex;
2469			point._index = index;
2470			point._model = {
2471				backgroundColor: options.backgroundColor,
2472				borderColor: options.borderColor,
2473				borderWidth: options.borderWidth,
2474				hitRadius: options.hitRadius,
2475				pointStyle: options.pointStyle,
2476				radius: reset ? 0 : options.radius,
2477				skip: custom.skip || isNaN(x) || isNaN(y),
2478				x: x,
2479				y: y,
2480			};
2481
2482			point.pivot();
2483		},
2484
2485		/**
2486		 * @protected
2487		 */
2488		setHoverStyle: function(point) {
2489			var model = point._model;
2490			var options = point._options;
2491
2492			model.backgroundColor = helpers.valueOrDefault(options.hoverBackgroun

2492dColor, helpers.getHoverColor(options.backgroundColor));
2493			model.borderColor = helpers.valueOrDefault(options.hoverBorderColor, helpers.getHoverColor(options.borderColor));
2494			model.borderWidth = helpers.valueOrDefault(options.hoverBorderWidth, options.borderWidth);
2495			model.radius = options.radius + options.hoverRadius;
2496		},
2497
2498		/**
2499		 * @protected
2500		 */
2501		removeHoverStyle: function(point) {
2502			var model = point._model;
2503			var options = point._options;
2504
2505			model.backgroundColor = options.backgroundColor;
2506			model.borderColor = options.borderColor;
2507			model.borderWidth = options.borderWidth;
2508			model.radius = options.radius;
2509		},
2510
2511		/**
2512		 * @private
2513		 */
2514		_resolveElementOptions: function(point, index) {
2515			var me = this;
2516			var chart = me.chart;
2517			var datasets = chart.data.datasets;
2518			var dataset = datasets[me.index];
2519			var custom = point.custom || {};
2520			var options = chart.options.elements.point;
2521			var resolve = helpers.options.resolve;
2522			var data = dataset.data[index];
2523			var values = {};
2524			var i, ilen, key;
2525
2526			// Scriptable options
2527			var context = {
2528				chart: chart,
2529				dataIndex: index,
2530				dataset: dataset,
2531				datasetIndex: me.index
2532			};
2533
2534			var keys = [
2535				'backgroundColor',
2536				'borderColor',
2537				'borderWidth',
2538				'hoverBackgroundColor',
2539				'hoverBorderColor',
2540				'hoverBorderWidth',
2541				'hoverRadius',
2542				'hitRadius',
2543				'pointStyle'
2544			];
2545
2546			for (i = 0, ilen = keys.length; i < ilen; ++i) {
2547				key = keys[i];
2548				values[key] = resolve([
2549					custom[key],
2550					dataset[key],
2551					options[key]
2552				], context, index);
2553			}
2554
2555			// Custom radius resolution
2556			values.radius = resolve([
2557				custom.radius,
2558				data ? data.r : undefined,
2559				dataset.radius,
2560				options.radius
2561			], context, index);
2562
2563			return values;
2564		}
2565	});
2566};
2567
2568},{"25":25,"40":40,"45":45}],17:[function(require,module,exports){
2569'use strict';
2570
2571var defaults = require(25);
2572var elements = require(40);
2573var helpers = require(45);
2574
2575defaults._set('doughnut', {
2576	animation: {
2577		// Boolean - Whether we animate the rotation of the Doughnut
2578		animateRotate: true,
2579		// Boolean - Whether we animate scaling the Doughnut from the centre
2580		animateScale: false
2581	},
2582	hover: {
2583		mode: 'single'
2584	},
2585	legendCallback: function(chart) {
2586		var text = [];
2587		text.push('<ul class="' + chart.id + '-legend">');
2588
2589		var data = chart.data;
2590		var datasets = data.datasets;
2591		var labels = data.labels;
2592
2593		if (datasets.length) {
2594			for (var i = 0; i < datasets[0].data.length; ++i) {
2595				text.push('<li><span style="background-color:' + datasets[0].backgroundColor[i] + '"></span>');
2596				if (labels[i]) {
2597					text.push(labels[i]);
2598				}
2599				text.push('</li>');
2600			}
2601		}
2602
2603		text.push('</ul>');
2604		return text.join('');
2605	},
2606	legend: {
2607		labels: {
2608			generateLabels: function(chart) {
2609				var data = chart.data;
2610				if (data.labels.length && data.datasets.length) {
2611					return data.labels.map(function(label, i) {
2612						var meta = chart.getDatasetMeta(0);
2613						var ds = data.datasets[0];
2614						var arc = meta.data[i];
2615						var custom = arc && arc.custom || {};
2616						var valueAtIndexOrDefault = helpers.valueAtIndexOrDefault;
2617						var arcOpts = chart.options.elements.arc;
2618						var fill = custom.backgroundColor ? custom.backgroundColor : valueAtIndexOrDefault(ds.backgroundColor, i, arcOpts.backgroundColor);
2619						var stroke = custom.borderColor ? custom.borderColor : valueAtIndexOrDefault(ds.borderColor, i, arcOpts.borderColor);
2620						var bw = custom.borderWidth ? custom.borderWidth : valueAtIndexOrDefault(ds.borderWidth, i, arcOpts.borderWidth);
2621
2622						return {
2623							text: label,
2624							fillStyle: fill,
2625							strokeStyle: stroke,
2626							lineWidth: bw,
2627							hidden: isNaN(ds.data[i]) || meta.data[i].hidden,
2628
2629							// Extra data used for toggling the correct item
2630							index: i
2631						};
2632					});
2633				}
2634				return [];
2635			}
2636		},
2637
2638		onClick: function(e, legendItem) {
2639			var index = legendItem.index;
2640			var chart = this.chart;
2641			var i, ilen, meta;
2642
2643			for (i = 0, ilen = (chart.data.datasets || []).length; i < ilen; ++i) {
2644				meta = chart.getDatasetMeta(i);
2645				// toggle visibility of index if exists
2646				if (meta.data[index]) {
2647					meta.data[index].hidden = !meta.data[index].hidden;
2648				}
2649			}
2650

2651			chart.update();
2652		}
2653	},
2654
2655	// The percentage of the chart that we cut out of the middle.
2656	cutoutPercentage: 50,
2657
2658	// The rotation of the chart, where the first data arc begins.
2659	rotation: Math.PI * -0.5,
2660
2661	// The total circumference of the chart.
2662	circumference: Math.PI * 2.0,
2663
2664	// Need to override these to give a nice default
2665	tooltips: {
2666		callbacks: {
2667			title: function() {
2668				return '';
2669			},
2670			label: function(tooltipItem, data) {
2671				var dataLabel = data.labels[tooltipItem.index];
2672				var value = ': ' + data.datasets[tooltipItem.datasetIndex].data[tooltipItem.index];
2673
2674				if (helpers.isArray(dataLabel)) {
2675					// show value on first line of multiline label
2676					// need to clone because we are changing the value
2677					dataLabel = dataLabel.slice();
2678					dataLabel[0] += value;
2679				} else {
2680					dataLabel += value;
2681				}
2682
2683				return dataLabel;
2684			}
2685		}
2686	}
2687});
2688
2689defaults._set('pie', helpers.clone(defaults.doughnut));
2690defaults._set('pie', {
2691	cutoutPercentage: 0
2692});
2693
2694module.exports = function(Chart) {
2695
2696	Chart.controllers.doughnut = Chart.controllers.pie = Chart.DatasetController.extend({
2697
2698		dataElementType: elements.Arc,
2699
2700		linkScales: helpers.noop,
2701
2702		// Get index of the dataset in relation to the visible datasets. This allows determining the inner and outer radius correctly
2703		getRingIndex: function(datasetIndex) {
2704			var ringIndex = 0;
2705
2706			for (var j = 0; j < datasetIndex; ++j) {
2707				if (this.chart.isDatasetVisible(j)) {
2708					++ringIndex;
2709				}
2710			}
2711
2712			return ringIndex;
2713		},
2714
2715		update: function(reset) {
2716			var me = this;
2717			var chart = me.chart;
2718			var chartArea = chart.chartArea;
2719			var opts = chart.options;
2720			var arcOpts = opts.elements.arc;
2721			var availableWidth = chartArea.right - chartArea.left - arcOpts.borderWidth;
2722			var availableHeight = chartArea.bottom - chartArea.top - arcOpts.borderWidth;
2723			var minSize = Math.min(availableWidth, availableHeight);
2724			var offset = {x: 0, y: 0};
2725			var meta = me.getMeta();
2726			var cutoutPercentage = opts.cutoutPercentage;
2727			var circumference = opts.circumference;
2728
2729			// If the chart's circumference isn't a full circle, calculate minSize as a ratio of the width/height of the arc
2730			if (circumference < Math.PI * 2.0) {
2731				var startAngle = opts.rotation % (Math.PI * 2.0);
2732				startAngle += Math.PI * 2.0 * (startAngle >= Math.PI ? -1 : startAngle < -Math.PI ? 1 : 0);
2733				var endAngle = startAngle + circumference;
2734				var start = {x: Math.cos(startAngle), y: Math.sin(startAngle)};
2735				var end = {x: Math.cos(endAngle), y: Math.sin(endAngle)};
2736				var contains0 = (startAngle <= 0 && endAngle >= 0) || (startAngle <= Math.PI * 2.0 && Math.PI * 2.0 <= endAngle);
2737				var contains90 = (startAngle <= Math.PI * 0.5 && Math.PI * 0.5 <= endAngle) || (startAngle <= Math.PI * 2.5 && Math.PI * 2.5 <= endAngle);
2738				var contains180 = (startAngle <= -Math.PI && -Math.PI <= endAngle) || (startAngle <= Math.PI && Math.PI <= endAngle);
2739				var contains270 = (startAngle <= -Math.PI * 0.5 && -Math.PI * 0.5 <= endAngle) || (startAngle <= Math.PI * 1.5 && Math.PI * 1.5 <= endAngle);
2740				var cutout = cutoutPercentage / 100.0;
2741				var min = {x: contains180 ? -1 : Math.min(start.x * (start.x < 0 ? 1 : cutout), end.x * (end.x < 0 ? 1 : cutout)), y: contains270 ? -1 : Math.min(start.y * (start.y < 0 ? 1 : cutout), end.y * (end.y < 0 ? 1 : cutout))};
2742				var max = {x: contains0 ? 1 : Math.max(start.x * (start.x > 0 ? 1 : cutout), end.x * (end.x > 0 ? 1 : cutout)), y: contains90 ? 1 : Math.max(start.y * (start.y > 0 ? 1 : cutout), end.y * (end.y > 0 ? 1 : cutout))};
2743				var size = {width: (max.x - min.x) * 0.5, height: (max.y - min.y) * 0.5};
2744				minSize = Math.min(availableWidth / size.width, availableHeight / size.height);
2745				offset = {x: (max.x + min.x) * -0.5, y: (max.y + min.y) * -0.5};
2746			}
2747
2748			chart.borderWidth = me.getMaxBorderWidth(meta.data);
2749			chart.outerRadius = Math.max((minSize - chart.borderWidth) / 2, 0);
2750			chart.innerRadius = Math.max(cutoutPercentage ? (chart.outerRadius / 100) * (cutoutPercentage) : 0, 0);
2751			chart.radiusLength = (chart.outerRadius - chart.innerRadius) / chart.getVisibleDatasetCount();
2752			chart.offsetX = offset.x * chart.outerRadius;
2753			chart.offsetY = offset.y * chart.outerRadius;
2754
2755			meta.total = me.calculateTotal();
2756