https://open.toscana.it/o/open-toscana-restyled-theme/js/vendors/chartsjs/Chart.js

1/*!
2 * Chart.js
3 * http://chartjs.org/
4 * Version: 2.7.3
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 r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({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(30)();
1674
1675Chart.helpers = require(46);
1676
1677// @todo dispatch these helpers into appropriated helpers/helpers.* file and write unit tests!
1678require(28)(Chart);
1679
1680Chart.Animation = require(22);
1681Chart.animationService = require(23);
1682Chart.defaults = require(26);
1683Chart.Element = require(27);
1684Chart.elements = require(41);
1685Chart.Interaction = require(29);
1686Chart.layouts = require(31);
1687Chart.platform = require(49);
1688Chart.plugins = require(32);
1689Chart.Scale = require(33);
1690Chart.scaleService = require(34);
1691Chart.Ticks = require(35);
1692Chart.Tooltip = require(36);
1693
1694require(24)(Chart);
1695require(25)(Chart);
1696
1697require(56)(Chart);
1698require(54)(Chart);
1699require(55)(Chart);
1700require(57)(Chart);
1701require(58)(Chart);
1702require(59)(Chart);
1703
1704// Controllers must be loaded after elements
1705// See Chart.core.datasetController.dataElementType
1706require(15)(Chart);
1707require(16)(Chart);
1708require(17)(Chart);
1709require(18)(Chart);
1710require(19)(Chart);
1711require(20)(Chart);
1712require(21)(Chart);
1713
1714require(8)(Chart);
1715require(9)(Chart);
1716require(10)(Chart);
1717require(11)(Chart);
1718require(12)(Chart);
1719require(13)(Chart);
1720require(14)(Chart);
1721
1722// Loading built-in plugins
1723var plugins = require(50);
1724for (var k in plugins) {
1725	if (plugins.hasOwnProperty(k)) {
1726		Chart.plugins.register(plugins[k]);
1727	}
1728}
1729
1730Chart.platform.initialize();
1731
1732module.exports = Chart;
1733if (typeof window !== 'undefined') {
1734	window.Chart = Chart;
1735}
1736
1737// DEPRECATIONS
1738
1739/**
1740 * Provided for backward compatibility, not available anymore
1741 * @namespace Chart.Legend
1742 * @deprecated since version 2.1.5
1743 * @todo remove at version 3
1744 * @private
1745 */

1746Chart.Legend = plugins.legend._element;
1747
1748/**
1749 * Provided for backward compatibility, not available anymore
1750 * @namespace Chart.Title
1751 * @deprecated since version 2.1.5
1752 * @todo remove at version 3
1753 * @private
1754 */
1755Chart.Title = plugins.title._element;
1756
1757/**
1758 * Provided for backward compatibility, use Chart.plugins instead
1759 * @namespace Chart.pluginService
1760 * @deprecated since version 2.1.5
1761 * @todo remove at version 3
1762 * @private
1763 */
1764Chart.pluginService = Chart.plugins;
1765
1766/**
1767 * Provided for backward compatibility, inheriting from Chart.PlugingBase has no
1768 * effect, instead simply create/register plugins via plain JavaScript objects.
1769 * @interface Chart.PluginBase
1770 * @deprecated since version 2.5.0
1771 * @todo remove at version 3
1772 * @private
1773 */
1774Chart.PluginBase = Chart.Element.extend({});
1775
1776/**
1777 * Provided for backward compatibility, use Chart.helpers.canvas instead.
1778 * @namespace Chart.canvasHelpers
1779 * @deprecated since version 2.6.0
1780 * @todo remove at version 3
1781 * @private
1782 */
1783Chart.canvasHelpers = Chart.helpers.canvas;
1784
1785/**
1786 * Provided for backward compatibility, use Chart.layouts instead.
1787 * @namespace Chart.layoutService
1788 * @deprecated since version 2.8.0
1789 * @todo remove at version 3
1790 * @private
1791 */

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

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

2373		mode: 'single'
2374	},
2375
2376	scales: {
2377		xAxes: [{
2378			type: 'linear', // bubble should probably use a linear scale by default
2379			position: 'bottom',
2380			id: 'x-axis-0' // need an ID so datasets can reference the scale
2381		}],
2382		yAxes: [{
2383			type: 'linear',
2384			position: 'left',
2385			id: 'y-axis-0'
2386		}]
2387	},
2388
2389	tooltips: {
2390		callbacks: {
2391			title: function() {
2392				// Title doesn't make sense for scatter since we format the data as a point
2393				return '';
2394			},
2395			label: function(item, data) {
2396				var datasetLabel = data.datasets[item.datasetIndex].label || '';
2397				var dataPoint = data.datasets[item.datasetIndex].data[item.index];
2398				return datasetLabel + ': (' + item.xLabel + ', ' + item.yLabel + ', ' + dataPoint.r + ')';
2399			}
2400		}
2401	}
2402});
2403
2404
2405module.exports = function(Chart) {
2406
2407	Chart.controllers.bubble = Chart.DatasetController.extend({
2408		/**
2409		 * @protected
2410		 */
2411		dataElementType: elements.Point,
2412
2413		/**
2414		 * @protected
2415		 */
2416		update: function(reset) {
2417			var me = this;
2418			var meta = me.getMeta();
2419			var points = meta.data;
2420
2421			// Update Points
2422			helpers.each(points, function(point, index) {
2423				me.updateElement(point, index, reset);
2424			});
2425		},
2426
2427		/**
2428		 * @protected
2429		 */
2430		updateElement: function(point, index, reset) {
2431			var me = this;
2432			var meta = me.getMeta();
2433			var custom = point.custom || {};
2434			var xScale = me.getScaleForId(meta.xAxisID);
2435			var yScale = me.getScaleForId(meta.yAxisID);
2436			var options = me._resolveElementOptions(point, index);
2437			var data = me.getDataset().data[index];
2438			var dsIndex = me.index;
2439
2440			var x = reset ? xScale.getPixelForDecimal(0.5) : xScale.getPixelForValue(typeof data === 'object' ? data : NaN, index, dsIndex);
2441			var y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(data, index, dsIndex);
2442
2443			point._xScale = xScale;
2444			point._yScale = yScale;
2445			point._options = options;
2446			point._datasetIndex = dsIndex;
2447			point._index = index;
2448			point._model = {
2449				backgroundColor: options.backgroundColor,
2450				borderColor: options.borderColor,
2451				borderWidth: options.borderWidth,
2452				hitRadius: options.hitRadius,
2453				pointStyle: options.pointStyle,
2454				rotation: options.rotation,
2455				radius: reset ? 0 : options.radius,
2456				skip: custom.skip || isNaN(x) || isNaN(y),
2457				x: x,
2458				y: y,
2459			};
2460
2461			point.pivot();
2462		},
2463
2464		/**
2465		 * @protected
2466		 */
2467		setHoverStyle: function(point) {
2468			var model = point._model;
2469			var options = point._options;
2470			point.$previousStyle = {
2471				backgroundColor: model.backgroundColor,
2472				borderColor: model.borderColor,
2473				borderWidth: model.borderWidth,
2474				radius: model.radius
2475			};
2476			model.backgroundColor = helpers.valueOrDefault(options.hoverBackgroundColor, helpers.getHoverColor(options.backgroundColor));
2477			model.borderColor = helpers.valueOrDefault(options.hoverBorderColor, helpers.getHoverColor(options.borderColor));
2478			model.borderWidth = helpers.valueOrDefault(options.hoverBorderWidth, options.borderWidth);
2479			model.radius = options.radius + options.hoverRadius;
2480		},
2481
2482		/**
2483		 * @private
2484		 */
2485		_resolveElementOptions: function(point, index) {
2486			var me = this;
2487			var chart = me.chart;
2488			var datasets = chart.data.datasets;
2489			var dataset = datasets[me.index];
2490			var custom = point.custom || {};
2491			var options = chart.options.elements.point;
2492			var resolve = helpers.options.resolve;
2493			var data = dataset.data[index];
2494			var values = {};
2495			var i, ilen, key;
2496
2497			// Scriptable options
2498			var context = {
2499				chart: chart,
2500				dataIndex: index,
2501				dataset: dataset,
2502				datasetIndex: me.index
2503			};
2504
2505			var keys = [
2506				'backgroundColor',
2507				'borderColor',
2508				'borderWidth',
2509				'hoverBackgroundColor',
2510				'hoverBorderColor',
2511				'hoverBorderWidth',
2512				'hoverRadius',
2513				'hitRadius',
2514				'pointStyle',
2515				'rotation'
2516			];
2517
2518			for (i = 0, ilen = keys.length; i < ilen; ++i) {
2519				key = keys[i];
2520				values[key] = resolve([
2521					custom[key],
2522					dataset[key],
2523					options[key]
2524				], context, index);
2525			}
2526
2527			// Custom radius resolution
2528			values.radius = resolve([
2529				custom.radius,
2530				data ? data.r : undefined,
2531				dataset.radius,
2532				options.radius
2533			], context, index);
2534			return values;
2535		}
2536	});
2537};
2538
2539},{"26":26,"41":41,"46":46}],17:[function(require,module,exports){
2540'use strict';
2541
2542var defaults = require(26);
2543var elements = require(41);
2544var helpers = require(46);
2545
2546defaults._set('doughnut', {
2547	animation: {
2548		// Boolean - Whether we animate the rotation of the Doughnut
2549		animateRotate: true,
2550		// Boolean - Whether we animate scaling the Doughnut from the centre
2551		animateScale: false
2552	},
2553	hover: {

2554		mode: 'single'
2555	},
2556	legendCallback: function(chart) {
2557		var text = [];
2558		text.push('<ul class="' + chart.id + '-legend">');
2559
2560		var data = chart.data;
2561		var datasets = data.datasets;
2562		var labels = data.labels;
2563
2564		if (datasets.length) {
2565			for (var i = 0; i < datasets[0].data.length; ++i) {
2566				text.push('<li><span style="background-color:' + datasets[0].backgroundColor[i] + '"></span>');
2567				if (labels[i]) {
2568					text.push(labels[i]);
2569				}
2570				text.push('</li>');
2571			}
2572		}
2573
2574		text.push('</ul>');
2575		return text.join('');
2576	},
2577	legend: {
2578		labels: {
2579			generateLabels: function(chart) {
2580				var data = chart.data;
2581				if (data.labels.length && data.datasets.length) {
2582					return data.labels.map(function(label, i) {
2583						var meta = chart.getDatasetMeta(0);
2584						var ds = data.datasets[0];
2585						var arc = meta.data[i];
2586						var custom = arc && arc.custom || {};
2587						var valueAtIndexOrDefault = helpers.valueAtIndexOrDefault;
2588						var arcOpts = chart.options.elements.arc;
2589						var fill = custom.backgroundColor ? custom.backgroundColor : valueAtIndexOrDefault(ds.backgroundColor, i, arcOpts.backgroundColor);
2590						var stroke = custom.borderColor ? custom.borderColor : valueAtIndexOrDefault(ds.borderColor, i, arcOpts.borderColor);
2591						var bw = custom.borderWidth ? custom.borderWidth : valueAtIndexOrDefault(ds.borderWidth, i, arcOpts.borderWidth);
2592
2593						return {
2594							text: label,
2595							fillStyle: fill,
2596							strokeStyle: stroke,
2597							lineWidth: bw,
2598							hidden: isNaN(ds.data[i]) || meta.data[i].hidden,
2599
2600							// Extra data used for toggling the correct item
2601							index: i
2602						};
2603					});
2604				}
2605				return [];
2606			}
2607		},
2608
2609		onClick: function(e, legendItem) {
2610			var index = legendItem.index;
2611			var chart = this.chart;
2612			var i, ilen, meta;
2613
2614			for (i = 0, ilen = (chart.data.datasets || []).length; i < ilen; ++i) {
2615				meta = chart.getDatasetMeta(i);
2616				// toggle visibility of index if exists
2617				if (meta.data[index]) {
2618					meta.data[index].hidden = !meta.data[index].hidden;
2619				}
2620			}
2621
2622			chart.update();
2623		}
2624	},
2625
2626	// The percentage of the chart that we cut out of the middle.
2627	cutoutPercentage: 50,
2628
2629	// The rotation of the chart, where the first data arc begins.
2630	rotation: Math.PI * -0.5,
2631
2632	// The total circumference of the chart.
2633	circumference: Math.PI * 2.0,
2634
2635	// Need to override these to give a nice default
2636	tooltips: {
2637		callbacks: {
2638			title: function() {
2639				return '';
2640			},
2641			label: function(tooltipItem, data) {
2642				var dataLabel = data.labels[tooltipItem.index];
2643				var value = ': ' + data.datasets[tooltipItem.datasetIndex].data[tooltipItem.index];
2644
2645				if (helpers.isArray(dataLabel)) {
2646					// show value on first line of multiline label
2647					// need to clone because we are changing the value
2648					dataLabel = dataLabel.slice();
2649					dataLabel[0] += value;
2650				} else {
2651					dataLabel += value;
2652				}
2653
2654				return dataLabel;
2655			}
2656		}
2657	}
2658});
2659
2660defaults._set('pie', helpers.clone(defaults.doughnut));
2661defaults._set('pie', {
2662	cutoutPercentage: 0
2663});
2664
2665module.exports = function(Chart) {
2666
2667	Chart.controllers.doughnut = Chart.controllers.pie = Chart.DatasetController.extend({
2668
2669		dataElementType: elements.Arc,
2670
2671		linkScales: helpers.noop,
2672
2673		// Get index of the dataset in relation to the visible datasets. This allows determining the inner and outer radius correctly
2674		getRingIndex: function(datasetIndex) {
2675			var ringIndex = 0;
2676
2677			for (var j = 0; j < datasetIndex; ++j) {
2678				if (this.chart.isDatasetVisible(j)) {
2679					++ringIndex;
2680				}
2681			}
2682
2683			return ringIndex;
2684		},
2685
2686		update: function(reset) {
2687			var me = this;
2688			var chart = me.chart;
2689			var chartArea = chart.chartArea;
2690			var opts = chart.options;
2691			var arcOpts = opts.elements.arc;
2692			var availableWidth = chartArea.right - chartArea.left - arcOpts.borderWidth;
2693			var availableHeight = chartArea.bottom - chartArea.top - arcOpts.borderWidth;
2694			var minSize = Math.min(availableWidth, availableHeight);
2695			var offset = {x: 0, y: 0};
2696			var meta = me.getMeta();
2697			var cutoutPercentage = opts.cutoutPercentage;
2698			var circumference = opts.circumference;
2699