https://my.lodgis.com/assets/js/main.js

240                "mediumturquoise": [72, 209, 204],
241                "mediumvioletred": [199, 21, 133],
242                "midnightblue": [25, 25, 112],
243                "mintcream": [245, 255, 250],
244                "mistyrose": [255, 228, 225],
245                "moccasin": [255, 228, 181],
246                "navajowhite": [255, 222, 173],
247                "navy": [0, 0, 128],
248                "oldlace": [253, 245, 230],
249                "olive": [128, 128, 0],
250                "olivedrab": [107, 142, 35],
251                "orange": [255, 165, 0],
252                "orangered": [255, 69, 0],
253                "orchid": [218, 112, 214],
254                "palegoldenrod": [238, 232, 170],
255                "palegreen": [152, 251, 152],
256                "paleturquoise": [175, 238, 238],
257                "palevioletred": [219, 112, 147],
258                "papayawhip": [255, 239, 213],
259                "peachpuff": [255, 218, 185],
260                "peru": [205, 133, 63],
261                "pink": [255, 192, 203],
262                "plum": [221, 160, 221],
263                "powderblue": [176, 224, 230],
264                "purple": [128, 0, 128],
265                "rebeccapurple": [102, 51, 153],
266                "red": [255, 0, 0],
267                "rosybrown": [188, 143, 143],
268                "royalblue": [65, 105, 225],
269                "saddlebrown": [139, 69, 19],
270                "salmon": [250, 128, 114],
271                "sandybrown": [244, 164, 96],
272                "seagreen": [46, 139, 87],
273                "seashell": [255, 245, 238],
274                "sienna": [160, 82, 45],
275                "silver": [192, 192, 192],
276                "skyblue": [135, 206, 235],
277                "slateblue": [106, 90, 205],
278                "slategray": [112, 128, 144],
279                "slategrey": [112, 128, 144],
280                "snow": [255, 250, 250],
281                "springgreen": [0, 255, 127],
282                "steelblue": [70, 130, 180],
283                "tan": [210, 180, 140],
284                "teal": [0, 128, 128],
285                "thistle": [216, 191, 216],
286                "tomato": [255, 99, 71],
287                "turquoise": [64, 224, 208],
288                "violet": [238, 130, 238],
289                "wheat": [245, 222, 179],
290                "white": [255, 255, 255],
291                "whitesmoke": [245, 245, 245],
292                "yellow": [255, 255, 0],
293                "yellowgreen": [154, 205, 50]
294            };
295
296            var conversions = createCommonjsModule(function (module) {
297                /* MIT license */
298
299
300// NOTE: conversions should only return primitive values (i.e. arrays, or
301//       values that give correct `typeof` results).
302//       do not use box values types (i.e. Number(), String(), etc.)
303
304                var reverseKeywords = {};
305                for (var key in colorName) {
306                    if (colorName.hasOwnProperty(key)) {
307                        reverseKeywords[colorName[key]] = key;
308                    }
309                }
310
311                var convert = module.exports = {
312                    rgb: {channels: 3, labels: 'rgb'},
313                    hsl: {channels: 3, labels: 'hsl'},
314                    hsv: {channels: 3, labels: 'hsv'},
315                    hwb: {channels: 3, labels: 'hwb'},
316                    cmyk: {channels: 4, labels: 'cmyk'},
317                    xyz: {channels: 3, labels: 'xyz'},
318                    lab: {channels: 3, labels: 'lab'},
319                    lch: {channels: 3, labels: 'lch'},
320                    hex: {channels: 1, labels: ['hex']},
321                    keyword: {channels: 1, labels: ['keyword']},
322                    ansi16: {channels: 1, labels: ['ansi16']},
323                    ansi256: {channels: 1, labels: ['ansi256']},
324                    hcg: {channels: 3, labels: ['h', 'c', 'g']},
325                    apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
326                    gray: {channels: 1, labels: ['gray']}
327                };
328
329// hide .channels and .labels properties
330                for (var model in convert) {
331                    if (convert.hasOwnProperty(model)) {
332                        if (!('channels' in convert[model])) {
333                            throw new Error('missing channels property: ' + model);
334                        }
335
336                        if (!('labels' in convert[model])) {
337                            throw new Error('missing channel labels property: ' + model);
338                        }
339
340                        if (convert[model].labels.length !== convert[model].channels) {
341                            throw new Error('channel and label counts mismatch: ' + model);
342                        }
343
344                        var channels = convert[model].channels;
345                        var labels = convert[model].labels;
346                        delete convert[model].channels;
347                        delete convert[model].labels;
348                        Object.defineProperty(convert[model], 'channels', {value: channels});
349                        Object.defineProperty(convert[model], 'labels', {value: labels});
350                    }
351                }
352
353                convert.rgb.hsl = function (rgb) {
354                    var r = rgb[0] / 255;
355                    var g = rgb[1] / 255;
356                    var b = rgb[2] / 255;
357                    var min = Math.min(r, g, b);
358                    var max = Math.max(r, g, b);
359                    var delta = max - min;
360                    var h;
361                    var s;
362                    var l;
363
364                    if (max === min) {
365                        h = 0;
366                    } else if (r === max) {
367                        h = (g - b) / delta;
368                    } else if (g === max) {
369                        h = 2 + (b - r) / delta;
370                    } else if (b === max) {
371                        h = 4 + (r - g) / delta;
372                    }
373
374                    h = Math.min(h * 60, 360);
375
376                    if (h < 0) {
377                        h += 360;
378                    }
379
380                    l = (min + max) / 2;
381
382                    if (max === min) {
383                        s = 0;
384                    } else if (l <= 0.5) {
385                        s = delta / (max + min);
386                    } else {
387                        s = delta / (2 - max - min);
388                    }
389
390                    return [h, s * 100, l * 100];
391                };
392
393                convert.rgb.hsv = function (rgb) {
394                    var rdif;
395                    var gdif;
396                    var bdif;
397                    var h;
398                    var s;
399
400                    var r = rgb[0] / 255;
401                    var g = rgb[1] / 255;
402                    var b = rgb[2] / 255;
403                    var v = Math.max(r, g, b);
404                    var diff = v - Math.min(r, g, b);
405                    var diffc = function (c) {
406                        return (v - c) / 6 / diff + 1 / 2;
407                    };
408
409                    if (diff === 0) {
410                        h = s = 0;
411                    } else {
412                        s = diff / v;
413                        rdif = diffc(r);
414                        gdif = diffc(g);
415                        bdif = diffc(b);
416
417                        if (r === v) {
418                            h = bdif - gdif;
419                        } else if (g === v) {
420                            h = (1 / 3) + rdif - bdif;
421                        } else if (b === v) {
422                            h = (2 / 3) + gdif - rdif;
423                        }
424                        if (h < 0) {
425                            h += 1;
426                        } else if (h > 1) {
427                            h -= 1;
428                        }
429                    }
430
431                    return [
432                        h * 360,
433                        s * 100,
434                        v * 100
435                    ];
436                };
437
438                convert.rgb.hwb = function (rgb) {
439                    var r = rgb[0];
440                    var g = rgb[1];
441                    var b = rgb[2];
442                    var h = convert.rgb.hsl(rgb)[0];
443                    var w = 1 / 255 * Math.min(r, Math.min(g, b));
444
445                    b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
446
447                    return [h, w * 100, b * 100];
448                };
449
450                convert.rgb.cmyk = function (rgb) {
451                    var r = rgb[0] / 255;
452                    var g = rgb[1] / 255;
453                    var b = rgb[2] / 255;
454                    var c;
455                    var m;
456                    var y;
457                    var k;
458
459                    k = Math.min(1 - r, 1 - g, 1 - b);
460                    c = (1 - r - k) / (1 - k) || 0;
461                    m = (1 - g - k) / (1 - k) || 0;
462                    y = (1 - b - k) / (1 - k) || 0;
463
464                    return [c * 100, m * 100, y * 100, k * 100];
465                };
466
467                /**
468                 * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
469                 * */
470                function comparativeDistance(x, y) {
471                    return (
472                        Math.pow(x[0] - y[0], 2) +
473                        Math.pow(x[1] - y[1], 2) +
474                        Math.pow(x[2] - y[2], 2)
475                    );
476                }
477
478                convert.rgb.keyword = function (rgb) {
479                    var reversed = reverseKeywords[rgb];
480                    if (reversed) {
481                        return reversed;
482                    }
483
484                    var currentClosestDistance = Infinity;
485                    var currentClosestKeyword;
486
487                    for (var keyword in colorName) {
488                        if (colorName.hasOwnProperty(keyword)) {
489                            var value = colorName[keyword];
490
491                            // Compute comparative distance
492                            var distance = comparativeDistance(rgb, value);
493
494                            // Check if its less, if so set as closest
495                            if (distance < currentClosestDistance) {
496                                currentClosestDistance = distance;
497                                currentClosestKeyword = keyword;
498                            }
499                        }
500                    }
501
502                    return currentClosestKeyword;
503                };
504
505                convert.keyword.rgb = function (keyword) {
506                    return colorName[keyword];
507                };
508
509                convert.rgb.xyz = function (rgb) {
510                    var r = rgb[0] / 255;
511                    var g = rgb[1] / 255;
512                    var b = rgb[2] / 255;
513
514                    // assume sRGB
515                    r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
516                    g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
517                    b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
518
519                    var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
520                    var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
521                    var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
522
523                    return [x * 100, y * 100, z * 100];
524                };
525
526                convert.rgb.lab = function (rgb) {
527                    var xyz = convert.rgb.xyz(rgb);
528                    var x = xyz[0];
529                    var y = xyz[1];
530                    var z = xyz[2];
531                    var l;
532                    var a;
533                    var b;
534
535                    x /= 95.047;
536                    y /= 100;
537                    z /= 108.883;
538
539                    x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
540                    y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
541                    z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
542
543                    l = (116 * y) - 16;
544                    a = 500 * (x - y);
545                    b = 200 * (y - z);
546
547                    return [l, a, b];
548                };
549
550                convert.hsl.rgb = function (hsl) {
551                    var h = hsl[0] / 360;
552                    var s = hsl[1] / 100;
553                    var l = hsl[2] / 100;
554                    var t1;
555                    var t2;
556                    var t3;
557                    var rgb;
558                    var val;
559
560                    if (s === 0) {
561                        val = l * 255;
562                        return [val, val, val];
563                    }
564
565                    if (l < 0.5) {
566                        t2 = l * (1 + s);
567                    } else {
568                        t2 = l + s - l * s;
569                    }
570
571                    t1 = 2 * l - t2;
572
573                    rgb = [0, 0, 0];
574                    for (var i = 0; i < 3; i++) {
575                        t3 = h + 1 / 3 * -(i - 1);
576                        if (t3 < 0) {
577                            t3++;
578                        }
579                        if (t3 > 1) {
580                            t3--;
581                        }
582
583                        if (6 * t3 < 1) {
584                            val = t1 + (t2 - t1) * 6 * t3;
585                        } else if (2 * t3 < 1) {
586                            val = t2;
587                        } else if (3 * t3 < 2) {
588                            val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
589                        } else {
590                            val = t1;
591                        }
592
593                        rgb[i] = val * 255;
594                    }
595
596                    return rgb;
597                };
598
599                convert.hsl.hsv = function (hsl) {
600                    var h = hsl[0];
601                    var s = hsl[1] / 100;
602                    var l = hsl[2] / 100;
603                    var smin = s;
604                    var lmin = Math.max(l, 0.01);
605                    var sv;
606                    var v;
607
608                    l *= 2;
609                    s *= (l <= 1) ? l : 2 - l;
610                    smin *= lmin <= 1 ? lmin : 2 - lmin;
611                    v = (l + s) / 2;
612                    sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
613
614                    return [h, sv * 100, v * 100];
615                };
616
617                convert.hsv.rgb = function (hsv) {
618                    var h = hsv[0] / 60;
619                    var s = hsv[1] / 100;
620                    var v = hsv[2] / 100;
621                    var hi = Math.floor(h) % 6;
622
623                    var f = h - Math.floor(h);
624                    var p = 255 * v * (1 - s);
625                    var q = 255 * v * (1 - (s * f));
626                    var t = 255 * v * (1 - (s * (1 - f)));
627                    v *= 255;
628
629                    switch (hi) {
630                        case 0:
631                            return [v, t, p];
632                        case 1:
633                            return [q, v, p];
634                        case 2:
635                            return [p, v, t];
636                        case 3:
637                            return [p, q, v];
638                        case 4:
639                            return [t, p, v];
640                        case 5:
641                            return [v, p, q];
642                    }
643                };
644
645                convert.hsv.hsl = function (hsv) {
646                    var h = hsv[0];
647                    var s = hsv[1] / 100;
648                    var v = hsv[2] / 100;
649                    var vmin = Math.max(v, 0.01);
650                    var lmin;
651                    var sl;
652                    var l;
653
654                    l = (2 - s) * v;
655                    lmin = (2 - s) * vmin;
656                    sl = s * vmin;
657                    sl /= (lmin <= 1) ? lmin : 2 - lmin;
658                    sl = sl || 0;
659                    l /= 2;
660
661                    return [h, sl * 100, l * 100];
662                };
663
664// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
665                convert.hwb.rgb = function (hwb) {
666                    var h = hwb[0] / 360;
667                    var wh = hwb[1] / 100;
668                    var bl = hwb[2] / 100;
669                    var ratio = wh + bl;
670                    var i;
671                    var v;
672                    var f;
673                    var n;
674
675                    // wh + bl cant be > 1
676                    if (ratio > 1) {
677                        wh /= ratio;
678                        bl /= ratio;
679                    }
680
681                    i = Math.floor(6 * h);
682                    v = 1 - bl;
683                    f = 6 * h - i;
684
685                    if ((i & 0x01) !== 0) {
686                        f = 1 - f;
687                    }
688
689                    n = wh + f * (v - wh); // linear interpolation
690
691                    var r;
692                    var g;
693                    var b;
694                    switch (i) {
695                        default:
696                        case 6:
697                        case 0:
698                            r = v;
699                            g = n;
700                            b = wh;
701                            break;
702                        case 1:
703                            r = n;
704                            g = v;
705                            b = wh;
706                            break;
707                        case 2:
708                            r = wh;
709                            g = v;
710                            b = n;
711                            break;
712                        case 3:
713                            r = wh;
714                            g = n;
715                            b = v;
716                            break;
717                        case 4:
718                            r = n;
719                            g = wh;
720                            b = v;
721                            break;
722                        case 5:
723                            r = v;
724                            g = wh;
725                            b = n;
726                            break;
727                    }
728
729                    return [r * 255, g * 255, b * 255];
730                };
731
732                convert.cmyk.rgb = function (cmyk) {
733                    var c = cmyk[0] / 100;
734                    var m = cmyk[1] / 100;
735                    var y = cmyk[2] / 100;
736                    var k = cmyk[3] / 100;
737                    var r;
738                    var g;
739                    var b;
740
741                    r = 1 - Math.min(1, c * (1 - k) + k);
742                    g = 1 - Math.min(1, m * (1 - k) + k);
743                    b = 1 - Math.min(1, y * (1 - k) + k);
744
745                    return [r * 255, g * 255, b * 255];
746                };
747
748                convert.xyz.rgb = function (xyz) {
749                    var x = xyz[0] / 100;
750                    var y = xyz[1] / 100;
751                    var z = xyz[2] / 100;
752                    var r;
753                    var g;
754                    var b;
755
756                    r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
757                    g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
758                    b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
759
760                    // assume sRGB
761                    r = r > 0.0031308
762                        ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
763                        : r * 12.92;
764
765                    g = g > 0.0031308
766                        ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
767                        : g * 12.92;
768
769                    b = b > 0.0031308
770                        ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
771                        : b * 12.92;
772
773                    r = Math.min(Math.max(0, r), 1);
774                    g = Math.min(Math.max(0, g), 1);
775                    b = Math.min(Math.max(0, b), 1);
776
777                    return [r * 255, g * 255, b * 255];
778                };
779
780                convert.xyz.lab = function (xyz) {
781                    var x = xyz[0];
782                    var y = xyz[1];
783                    var z = xyz[2];
784                    var l;
785                    var a;
786                    var b;
787
788                    x /= 95.047;
789                    y /= 100;
790                    z /= 108.883;
791
792                    x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
793                    y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
794                    z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
795
796                    l = (116 * y) - 16;
797                    a = 500 * (x - y);
798                    b = 200 * (y - z);
799
800                    return [l, a, b];
801                };
802
803                convert.lab.xyz = function (lab) {
804                    var l = lab[0];
805                    var a = lab[1];
806                    var b = lab[2];
807                    var x;
808                    var y;
809                    var z;
810
811                    y = (l + 16) / 116;
812                    x = a / 500 + y;
813                    z = y - b / 200;
814
815                    var y2 = Math.pow(y, 3);
816                    var x2 = Math.pow(x, 3);
817                    var z2 = Math.pow(z, 3);
818                    y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
819                    x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
820                    z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
821
822                    x *= 95.047;
823                    y *= 100;
824                    z *= 108.883;
825
826                    return [x, y, z];
827                };
828
829                convert.lab.lch = function (lab) {
830                    var l = lab[0];
831                    var a = lab[1];
832                    var b = lab[2];
833                    var hr;
834                    var h;
835                    var c;
836
837                    hr = Math.atan2(b, a);
838                    h = hr * 360 / 2 / Math.PI;
839
840                    if (h < 0) {
841                        h += 360;
842                    }
843
844                    c = Math.sqrt(a * a + b * b);
845
846                    return [l, c, h];
847                };
848
849                convert.lch.lab = function (lch) {
850                    var l = lch[0];
851                    var c = lch[1];
852                    var h = lch[2];
853                    var a;
854                    var b;
855                    var hr;
856
857                    hr = h / 360 * 2 * Math.PI;
858                    a = c * Math.cos(hr);
859                    b = c * Math.sin(hr);
860
861                    return [l, a, b];
862                };
863
864                convert.rgb.ansi16 = function (args) {
865                    var r = args[0];
866                    var g = args[1];
867                    var b = args[2];
868                    var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
869
870                    value = Math.round(value / 50);
871
872                    if (value === 0) {
873                        return 30;
874                    }
875
876                    var ansi = 30
877                        + ((Math.round(b / 255) << 2)
878                            | (Math.round(g / 255) << 1)
879                            | Math.round(r / 255));
880
881                    if (value === 2) {
882                        ansi += 60;
883                    }
884
885                    return ansi;
886                };
887
888                convert.hsv.ansi16 = function (args) {
889                    // optimization here; we already know the value and don't need to get
890                    // it converted for us.
891                    return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
892                };
893
894                convert.rgb.ansi256 = function (args) {
895                    var r = args[0];
896                    var g = args[1];
897                    var b = args[2];
898
899                    // we use the extended greyscale palette here, with the exception of
900                    // black and white. normal palette only has 4 greyscale shades.
901                    if (r === g && g === b) {
902                        if (r < 8) {
903                            return 16;
904                        }
905
906                        if (r > 248) {
907                            return 231;
908                        }
909
910                        return Math.round(((r - 8) / 247) * 24) + 232;
911                    }
912
913                    var ansi = 16
914                        + (36 * Math.round(r / 255 * 5))
915                        + (6 * Math.round(g / 255 * 5))
916                        + Math.round(b / 255 * 5);
917
918                    return ansi;
919                };
920
921                convert.ansi16.rgb = function (args) {
922                    var color = args % 10;
923
924                    // handle greyscale
925                    if (color === 0 || color === 7) {
926                        if (args > 50) {
927                            color += 3.5;
928                        }
929
930                        color = color / 10.5 * 255;
931
932                        return [color, color, color];
933                    }
934
935                    var mult = (~~(args > 50) + 1) * 0.5;
936                    var r = ((color & 1) * mult) * 255;
937                    var g = (((color >> 1) & 1) * mult) * 255;
938                    var b = (((color >> 2) & 1) * mult) * 255;
939
940                    return [r, g, b];
941                };
942
943                convert.ansi256.rgb = function (args) {
944                    // handle greyscale
945                    if (args >= 232) {
946                        var c = (args - 232) * 10 + 8;
947                        return [c, c, c];
948                    }
949
950                    args -= 16;
951
952                    var rem;
953                    var r = Math.floor(args / 36) / 5 * 255;
954                    var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
955                    var b = (rem % 6) / 5 * 255;
956
957                    return [r, g, b];
958                };
959
960                convert.rgb.hex = function (args) {
961                    var integer = ((Math.round(args[0]) & 0xFF) << 16)
962                        + ((Math.round(args[1]) & 0xFF) << 8)
963                        + (Math.round(args[2]) & 0xFF);
964
965                    var string = integer.toString(16).toUpperCase();
966                    return '000000'.substring(string.length) + string;
967                };
968
969                convert.hex.rgb = function (args) {
970                    var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
971                    if (!match) {
972                        return [0, 0, 0];
973                    }
974
975                    var colorString = match[0];
976
977                    if (match[0].length === 3) {
978                        colorString = colorString.split('').map(function (char) {
979                            return char + char;
980                        }).join('');
981                    }
982
983                    var integer = parseInt(colorString, 16);
984                    var r = (integer >> 16) & 0xFF;
985                    var g = (integer >> 8) & 0xFF;
986                    var b = integer & 0xFF;
987
988                    return [r, g, b];
989                };
990
991                convert.rgb.hcg = function (rgb) {
992                    var r = rgb[0] / 255;
993                    var g = rgb[1] / 255;
994                    var b = rgb[2] / 255;
995                    var max = Math.max(Math.max(r, g), b);
996                    var min = Math.min(Math.min(r, g), b);
997                    var chroma = (max - min);
998                    var grayscale;
999                    var hue;
1000
1001                    if (chroma < 1) {
1002                        grayscale = min / (1 - chroma);
1003                    } else {
1004                        grayscale = 0;
1005                    }
1006
1007                    if (chroma <= 0) {
1008                        hue = 0;
1009                    } else if (max === r) {
1010                        hue = ((g - b) / chroma) % 6;
1011                    } else if (max === g) {
1012                        hue = 2 + (b - r) / chroma;
1013                    } else {
1014                        hue = 4 + (r - g) / chroma + 4;
1015                    }
1016
1017                    hue /= 6;
1018                    hue %= 1;
1019
1020                    return [hue * 360, chroma * 100, grayscale * 100];
1021                };
1022
1023                convert.hsl.hcg = function (hsl) {
1024                    var s = hsl[1] / 100;
1025                    var l = hsl[2] / 100;
1026                    var c = 1;
1027                    var f = 0;
1028
1029                    if (l < 0.5) {
1030                        c = 2.0 * s * l;
1031                    } else {
1032                        c = 2.0 * s * (1.0 - l);
1033                    }
1034
1035                    if (c < 1.0) {
1036                        f = (l - 0.5 * c) / (1.0 - c);
1037                    }
1038
1039                    return [hsl[0], c * 100, f * 100];
1040                };
1041
1042                convert.hsv.hcg = function (hsv) {
1043                    var s = hsv[1] / 100;
1044                    var v = hsv[2] / 100;
1045
1046                    var c = s * v;
1047                    var f = 0;
1048
1049                    if (c < 1.0) {
1050                        f = (v - c) / (1 - c);
1051                    }
1052
1053                    return [hsv[0], c * 100, f * 100];
1054                };
1055
1056                convert.hcg.rgb = function (hcg) {
1057                    var h = hcg[0] / 360;
1058                    var c = hcg[1] / 100;
1059                    var g = hcg[2] / 100;
1060
1061                    if (c === 0.0) {
1062                        return [g * 255, g * 255, g * 255];
1063                    }
1064
1065                    var pure = [0, 0, 0];
1066                    var hi = (h % 1) * 6;
1067                    var v = hi % 1;
1068                    var w = 1 - v;
1069                    var mg = 0;
1070
1071                    switch (Math.floor(hi)) {
1072                        case 0:
1073                            pure[0] = 1;
1074                            pure[1] = v;
1075                            pure[2] = 0;
1076                            break;
1077                        case 1:
1078                            pure[0] = w;
1079                            pure[1] = 1;
1080                            pure[2] = 0;
1081                            break;
1082                        case 2:
1083                            pure[0] = 0;
1084                            pure[1] = 1;
1085                            pure[2] = v;
1086                            break;
1087                        case 3:
1088                            pure[0] = 0;
1089                            pure[1] = w;
1090                            pure[2] = 1;
1091                            break;
1092                        case 4:
1093                            pure[0] = v;
1094                            pure[1] = 0;
1095                            pure[2] = 1;
1096                            break;
1097                        default:
1098                            pure[0] = 1;
1099                            pure[1] = 0;
1100                            pure[2] = w;
1101                    }
1102
1103                    mg = (1.0 - c) * g;
1104
1105                    return [
1106                        (c * pure[0] + mg) * 255,
1107                        (c * pure[1] + mg) * 255,
1108                        (c * pure[2] + mg) * 255
1109                    ];
1110                };
1111
1112                convert.hcg.hsv = function (hcg) {
1113                    var c = hcg[1] / 100;
1114                    var g = hcg[2] / 100;
1115
1116                    var v = c + g * (1.0 - c);
1117                    var f = 0;
1118
1119                    if (v > 0.0) {
1120                        f = c / v;
1121                    }
1122
1123                    return [hcg[0], f * 100, v * 100];
1124                };
1125
1126                convert.hcg.hsl = function (hcg) {
1127                    var c = hcg[1] / 100;
1128                    var g = hcg[2] / 100;
1129
1130                    var l = g * (1.0 - c) + 0.5 * c;
1131                    var s = 0;
1132
1133                    if (l > 0.0 && l < 0.5) {
1134                        s = c / (2 * l);
1135                    } else if (l >= 0.5 && l < 1.0) {
1136                        s = c / (2 * (1 - l));
1137                    }
1138
1139                    return [hcg[0], s * 100, l * 100];
1140                };
1141
1142                convert.hcg.hwb = function (hcg) {
1143                    var c = hcg[1] / 100;
1144                    var g = hcg[2] / 100;
1145                    var v = c + g * (1.0 - c);
1146                    return [hcg[0], (v - c) * 100, (1 - v) * 100];
1147                };
1148
1149                convert.hwb.hcg = function (hwb) {
1150                    var w = hwb[1] / 100;
1151                    var b = hwb[2] / 100;
1152                    var v = 1 - b;
1153                    var c = v - w;
1154                    var g = 0;
1155
1156                    if (c < 1) {
1157                        g = (v - c) / (1 - c);
1158                    }
1159
1160                    return [hwb[0], c * 100, g * 100];
1161                };
1162
1163                convert.apple.rgb = function (apple) {
1164                    return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
1165                };
1166
1167                convert.rgb.apple = function (rgb) {
1168                    return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
1169                };
1170
1171                convert.gray.rgb = function (args) {
1172                    return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
1173                };
1174
1175                convert.gray.hsl = convert.gray.hsv = function (args) {
1176                    return [0, 0, args[0]];
1177                };
1178
1179                convert.gray.hwb = function (gray) {
1180                    return [0, 100, gray[0]];
1181                };
1182
1183                convert.gray.cmyk = function (gray) {
1184                    return [0, 0, 0, gray[0]];
1185                };
1186
1187                convert.gray.lab = function (gray) {
1188                    return [gray[0], 0, 0];
1189                };
1190
1191                convert.gray.hex = function (gray) {
1192                    var val = Math.round(gray[0] / 100 * 255) & 0xFF;
1193                    var integer = (val << 16) + (val << 8) + val;
1194
1195                    var string = integer.toString(16).toUpperCase();
1196                    return '000000'.substring(string.length) + string;
1197                };
1198
1199                convert.rgb.gray = function (rgb) {
1200                    var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
1201                    return [val / 255 * 100];
1202                };
1203            });
1204            var conversions_1 = conversions.rgb;
1205            var conversions_2 = conversions.hsl;
1206            var conversions_3 = conversions.hsv;
1207            var conversions_4 = conversions.hwb;
1208            var conversions_5 = conversions.cmyk;
1209            var conversions_6 = conversions.xyz;
1210            var conversions_7 = conversions.lab;
1211            var conversions_8 = conversions.lch;
1212            var conversions_9 = conversions.hex;
1213            var conversions_10 = conversions.keyword;
1214            var conversions_11 = conversions.ansi16;
1215            var conversions_12 = conversions.ansi256;
1216            var conversions_13 = conversions.hcg;
1217            var conversions_14 = conversions.apple;
1218            var conversions_15 = conversions.gray;
1219
1220            /*
1221	this function routes a model to all other models.
1222
1223	all functions that are routed have a property `.conversion` attached
1224	to the returned synthetic function. This property is an array
1225	of strings, each with the steps in between the 'from' and 'to'
1226	color models (inclusive).
1227
1228	conversions that are not possible simply are not included.
1229*/
1230
1231            function buildGraph() {
1232                var graph = {};
1233                // https://jsperf.com/object-keys-vs-for-in-with-closure/3
1234                var models = Object.keys(conversions);
1235
1236                for (var len = models.length, i = 0; i < len; i++) {
1237                    graph[models[i]] = {
1238                        // http://jsperf.com/1-vs-infinity
1239                        // micro-opt, but this is simple.
1240                        distance: -1,
1241                        parent: null
1242                    };
1243                }
1244
1245                return graph;
1246            }
1247
1248// https://en.wikipedia.org/wiki/Breadth-first_search
1249            function deriveBFS(fromModel) {
1250                var graph = buildGraph();
1251                var queue = [fromModel]; // unshift -> queue -> pop
1252
1253                graph[fromModel].distance = 0;
1254
1255                while (queue.length) {
1256                    var current = queue.pop();
1257                    var adjacents = Object.keys(conversions[current]);
1258
1259                    for (var len = adjacents.length, i = 0; i < len; i++) {
1260                        var adjacent = adjacents[i];
1261                        var node = graph[adjacent];
1262
1263                        if (node.distance === -1) {
1264                            node.distance = graph[current].distance + 1;
1265                            node.parent = current;
1266                            queue.unshift(adjacent);
1267                        }
1268                    }
1269                }
1270
1271                return graph;
1272            }
1273
1274            function link(from, to) {
1275                return function (args) {
1276                    return to(from(args));
1277                };
1278            }
1279
1280            function wrapConversion(toModel, graph) {
1281                var path = [graph[toModel].parent, toModel];
1282                var fn = conversions[graph[toModel].parent][toModel];
1283
1284                var cur = graph[toModel].parent;
1285                while (graph[cur].parent) {
1286                    path.unshift(graph[cur].parent);
1287                    fn = link(conversions[graph[cur].parent][cur], fn);
1288                    cur = graph[cur].parent;
1289                }
1290
1291                fn.conversion = path;
1292                return fn;
1293            }
1294
1295            var route = function (fromModel) {
1296                var graph = deriveBFS(fromModel);
1297                var conversion = {};
1298
1299                var models = Object.keys(graph);
1300                for (var len = models.length, i = 0; i < len; i++) {
1301                    var toModel = models[i];
1302                    var node = graph[toModel];
1303
1304                    if (node.parent === null) {
1305                        // no possible conversion, or this node is the source model.
1306                        continue;
1307                    }
1308
1309                    conversion[toModel] = wrapConversion(toModel, graph);
1310                }
1311
1312                return conversion;
1313            };
1314
1315            var convert = {};
1316
1317            var models = Object.keys(conversions);
1318
1319            function wrapRaw(fn) {
1320                var wrappedFn = function (args) {
1321                    if (args === undefined || args === null) {
1322                        return args;
1323                    }
1324
1325                    if (arguments.length > 1) {
1326                        args = Array.prototype.slice.call(arguments);
1327                    }
1328
1329                    return fn(args);
1330                };
1331
1332                // preserve .conversion property if there is one
1333                if ('conversion' in fn) {
1334                    wrappedFn.conversion = fn.conversion;
1335                }
1336
1337                return wrappedFn;
1338            }
1339
1340            function wrapRounded(fn) {
1341                var wrappedFn = function (args) {
1342                    if (args === undefined || args === null) {
1343                        return args;
1344                    }
1345
1346                    if (arguments.length > 1) {
1347                        args = Array.prototype.slice.call(arguments);
1348                    }
1349
1350                    var result = fn(args);
1351
1352                    // we're assuming the result is an array here.
1353                    // see notice in conversions.js; don't use box types
1354                    // in conversion functions.
1355                    if (typeof result === 'object') {
1356                        for (var len = result.length, i = 0; i < len; i++) {
1357                            result[i] = Math.round(result[i]);
1358                        }
1359                    }
1360
1361                    return result;
1362                };
1363
1364                // preserve .conversion property if there is one
1365                if ('conversion' in fn) {
1366                    wrappedFn.conversion = fn.conversion;
1367                }
1368
1369                return wrappedFn;
1370            }
1371
1372            models.forEach(function (fromModel) {
1373                convert[fromModel] = {};
1374
1375                Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
1376                Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
1377
1378                var routes = route(fromModel);
1379                var routeModels = Object.keys(routes);
1380
1381                routeModels.forEach(function (toModel) {
1382                    var fn = routes[toModel];
1383
1384                    convert[fromModel][toModel] = wrapRounded(fn);
1385                    convert[fromModel][toModel].raw = wrapRaw(fn);
1386                });
1387            });
1388
1389            var colorConvert = convert;
1390
1391            var colorName$1 = {
1392                "aliceblue": [240, 248, 255],
1393                "antiquewhite": [250, 235, 215],
1394                "aqua": [0, 255, 255],
1395                "aquamarine": [127, 255, 212],
1396                "azure": [240, 255, 255],
1397                "beige": [245, 245, 220],
1398                "bisque": [255, 228, 196],
1399                "black": [0, 0, 0],
1400                "blanchedalmond": [255, 235, 205],
1401                "blue": [0, 0, 255],
1402                "blueviolet": [138, 43, 226],
1403                "brown": [165, 42, 42],
1404                "burlywood": [222, 184, 135],
1405                "cadetblue": [95, 158, 160],
1406                "chartreuse": [127, 255, 0],
1407                "chocolate": [210, 105, 30],
1408                "coral": [255, 127, 80],
1409                "cornflowerblue": [100, 149, 237],
1410                "cornsilk": [255, 248, 220],
1411                "crimson": [220, 20, 60],
1412                "cyan": [0, 255, 255],
1413                "darkblue": [0, 0, 139],
1414                "darkcyan": [0, 139, 139],
1415                "darkgoldenrod": [184, 134, 11],
1416                "darkgray": [169, 169, 169],
1417                "darkgreen": [0, 100, 0],
1418                "darkgrey": [169, 169, 169],
1419                "darkkhaki": [189, 183, 107],
1420                "darkmagenta": [139, 0, 139],
1421                "darkolivegreen": [85, 107, 47],
1422                "darkorange": [255, 140, 0],
1423                "darkorchid": [153, 50, 204],
1424                "darkred": [139, 0, 0],
1425                "darksalmon": [233, 150, 122],
1426                "darkseagreen": [143, 188, 143],
1427                "darkslateblue": [72, 61, 139],
1428                "darkslategray": [47, 79, 79],
1429                "darkslategrey": [47, 79, 79],
1430                "darkturquoise": [0, 206, 209],
1431                "darkviolet": [148, 0, 211],
1432                "deeppink": [255, 20, 147],
1433                "deepskyblue": [0, 191, 255],
1434                "dimgray": [105, 105, 105],
1435                "dimgrey": [105, 105, 105],
1436                "dodgerblue": [30, 144, 255],
1437                "firebrick": [178, 34, 34],
1438                "floralwhite": [255, 250, 240],
1439                "forestgreen": [34, 139, 34],
1440                "fuchsia": [255, 0, 255],
1441                "gainsboro": [220, 220, 220],
1442                "ghostwhite": [248, 248, 255],
1443                "gold": [255, 215, 0],
1444                "goldenrod": [218, 165, 32],
1445                "gray": [128, 128, 128],
1446                "green": [0, 128, 0],
1447                "greenyellow": [173, 255, 47],
1448                "grey": [128, 128, 128],
1449                "honeydew": [240, 255, 240],
1450                "hotpink": [255, 105, 180],
1451                "indianred": [205, 92, 92],
1452                "indigo": [75, 0, 130],
1453                "ivory": [255, 255, 240],
1454                "khaki": [240, 230, 140],
1455                "lavender": [230, 230, 250],
1456                "lavenderblush": [255, 240, 245],
1457                "lawngreen": [124, 252, 0],
1458                "lemonchiffon": [255, 250, 205],
1459                "lightblue": [173, 216, 230],
1460                "lightcoral": [240, 128, 128],
1461                "lightcyan": [224, 255, 255],
1462                "lightgoldenrodyellow": [250, 250, 210],
1463                "lightgray": [211, 211, 211],
1464                "lightgreen": [144, 238, 144],
1465                "lightgrey": [211, 211, 211],
1466                "lightpink": [255, 182, 193],
1467                "lightsalmon": [255, 160, 122],
1468                "lightseagreen": [32, 178, 170],
1469                "lightskyblue": [135, 206, 250],
1470                "lightslategray": [119, 136, 153],
1471                "lightslategrey": [119, 136, 153],
1472                "lightsteelblue": [176, 196, 222],
1473                "lightyellow": [255, 255, 224],
1474                "lime": [0, 255, 0],
1475                "limegreen": [50, 205, 50],
1476                "linen": [250, 240, 230],
1477                "magenta": [255, 0, 255],
1478                "maroon": [128, 0, 0],
1479                "mediumaquamarine": [102, 205, 170],
1480                "mediumblue": [0, 0, 205],
1481                "mediumorchid": [186, 85, 211],
1482                "mediumpurple": [147, 112, 219],
1483                "mediumseagreen": [60, 179, 113],
1484                "mediumslateblue": [123, 104, 238],
1485                "mediumspringgreen": [0, 250, 154],
1486                "mediumturquoise": [72, 209, 204],
1487                "mediumvioletred": [199, 21, 133],
1488                "midnightblue": [25, 25, 112],
1489                "mintcream": [245, 255, 250],
1490                "mistyrose": [255, 228, 225],
1491                "moccasin": [255, 228, 181],
1492                "navajowhite": [255, 222, 173],
1493                "navy": [0, 0, 128],
1494                "oldlace": [253, 245, 230],
1495                "olive": [128, 128, 0],
1496                "olivedrab": [107, 142, 35],
1497                "orange": [255, 165, 0],
1498                "orangered": [255, 69, 0],
1499                "orchid": [218, 112, 214],
1500                "palegoldenrod": [238, 232, 170],
1501                "palegreen": [152, 251, 152],
1502                "paleturquoise": [175, 238, 238],
1503                "palevioletred": [219, 112, 147],
1504                "papayawhip": [255, 239, 213],
1505                "peachpuff": [255, 218, 185],
1506                "peru": [205, 133, 63],
1507                "pink": [255, 192, 203],
1508                "plum": [221, 160, 221],
1509                "powderblue": [176, 224, 230],
1510                "purple": [128, 0, 128],
1511                "rebeccapurple": [102, 51, 153],
1512                "red": [255, 0, 0],
1513                "rosybrown": [188, 143, 143],
1514                "royalblue": [65, 105, 225],
1515                "saddlebrown": [139, 69, 19],
1516                "salmon": [250, 128, 114],
1517                "sandybrown": [244, 164, 96],
1518                "seagreen": [46, 139, 87],
1519                "seashell": [255, 245, 238],
1520                "sienna": [160, 82, 45],
1521                "silver": [192, 192, 192],
1522                "skyblue": [135, 206, 235],
1523                "slateblue": [106, 90, 205],
1524                "slategray": [112, 128, 144],
1525                "slategrey": [112, 128, 144],
1526                "snow": [255, 250, 250],
1527                "springgreen": [0, 255, 127],
1528                "steelblue": [70, 130, 180],
1529                "tan": [210, 180, 140],
1530                "teal": [0, 128, 128],
1531                "thistle": [216, 191, 216],
1532                "tomato": [255, 99, 71],
1533                "turquoise": [64, 224, 208],
1534                "violet": [238, 130, 238],
1535                "wheat": [245, 222, 179],
1536                "white": [255, 255, 255],
1537                "whitesmoke": [245, 245, 245],
1538                "yellow": [255, 255, 0],
1539                "yellowgreen": [154, 205, 50]
1540            };
1541
1542            /* MIT license */
1543
1544
1545            var colorString = {
1546                getRgba: getRgba,
1547                getHsla: getHsla,
1548                getRgb: getRgb,
1549                getHsl: getHsl,
1550                getHwb: getHwb,
1551                getAlpha: getAlpha,
1552
1553                hexString: hexString,
1554                rgbString: rgbString,
1555                rgbaString: rgbaString,
1556                percentString: percentString,
1557                percentaString: percentaString,
1558                hslString: hslString,
1559                hslaString: hslaString,
1560                hwbString: hwbString,
1561                keyword: keyword
1562            };
1563
1564            function getRgba(string) {
1565                if (!string) {
1566                    return;
1567                }
1568                var abbr = /^#([a-fA-F0-9]{3,4})$/i,
1569                    hex = /^#([a-fA-F0-9]{6}([a-fA-F0-9]{2})?)$/i,
1570                    rgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
1571                    per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i,
1572                    keyword = /(\w+)/;
1573
1574                var rgb = [0, 0, 0],
1575                    a = 1,
1576                    match = string.match(abbr),
1577                    hexAlpha = "";
1578                if (match) {
1579                    match = match[1];
1580                    hexAlpha = match[3];
1581                    for (var i = 0; i < rgb.length; i++) {
1582                        rgb[i] = parseInt(match[i] + match[i], 16);
1583                    }
1584                    if (hexAlpha) {
1585                        a = Math.round((parseInt(hexAlpha + hexAlpha, 16) / 255) * 100) / 100;
1586                    }
1587                } else if (match = string.match(hex)) {
1588                    hexAlpha = match[2];
1589                    match = match[1];
1590                    for (var i = 0; i < rgb.length; i++) {
1591                        rgb[i] = parseInt(match.slice(i * 2, i * 2 + 2), 16);
1592                    }
1593                    if (hexAlpha) {
1594                        a = Math.round((parseInt(hexAlpha, 16) / 255) * 100) / 100;
1595                    }
1596                } else if (match = string.match(rgba)) {
1597                    for (var i = 0; i < rgb.length; i++) {
1598                        rgb[i] = parseInt(match[i + 1]);
1599                    }
1600                    a = parseFloat(match[4]);
1601                } else if (match = string.match(per)) {
1602                    for (var i = 0; i < rgb.length; i++) {
1603                        rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
1604                    }
1605                    a = parseFloat(match[4]);
1606                } else if (match = string.match(keyword)) {
1607                    if (match[1] == "transparent") {
1608                        return [0, 0, 0, 0];
1609                    }
1610                    rgb = colorName$1[match[1]];
1611                    if (!rgb) {
1612                        return;
1613                    }
1614                }
1615
1616                for (var i = 0; i < rgb.length; i++) {
1617                    rgb[i] = scale(rgb[i], 0, 255);
1618                }
1619                if (!a && a != 0) {
1620                    a = 1;
1621                } else {
1622                    a = scale(a, 0, 1);
1623                }
1624                rgb[3] = a;
1625                return rgb;
1626            }
1627
1628            function getHsla(string) {
1629                if (!string) {
1630                    return;
1631                }
1632                var hsl = /^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/;
1633                var match = string.match(hsl);
1634                if (match) {
1635                    var alpha = parseFloat(match[4]);
1636                    var h = scale(parseInt(match[1]), 0, 360),
1637                        s = scale(parseFloat(match[2]), 0, 100),
1638                        l = scale(parseFloat(match[3]), 0, 100),
1639                        a = scale(isNaN(alpha) ? 1 : alpha, 0, 1);
1640                    return [h, s, l, a];
1641                }
1642            }
1643
1644            function getHwb(string) {
1645                if (!string) {
1646                    return;
1647                }
1648                var hwb = /^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/;
1649                var match = string.match(hwb);
1650                if (match) {
1651                    var alpha = parseFloat(match[4]);
1652                    var h = scale(parseInt(match[1]), 0, 360),
1653                        w = scale(parseFloat(match[2]), 0, 100),
1654                        b = scale(parseFloat(match[3]), 0, 100),
1655                        a = scale(isNaN(alpha) ? 1 : alpha, 0, 1);
1656                    return [h, w, b, a];
1657                }
1658            }
1659
1660            function getRgb(string) {
1661                var rgba = getRgba(string);
1662                return rgba && rgba.slice(0, 3);
1663            }
1664
1665            function getHsl(string) {
1666                var hsla = getHsla(string);
1667                return hsla && hsla.slice(0, 3);
1668            }
1669
1670            function getAlpha(string) {
1671                var vals = getRgba(string);
1672                if (vals) {
1673                    return vals[3];
1674                } else if (vals = getHsla(string)) {
1675                    return vals[3];
1676                } else if (vals = getHwb(string)) {
1677                    return vals[3];
1678                }
1679            }
1680
1681// generators
1682            function hexString(rgba, a) {
1683                var a = (a !== undefined && rgba.length === 3) ? a : rgba[3];
1684                return "#" + hexDouble(rgba[0])
1685                    + hexDouble(rgba[1])
1686                    + hexDouble(rgba[2])
1687                    + (
1688                        (a >= 0 && a < 1)
1689                            ? hexDouble(Math.round(a * 255))
1690                            : ""
1691                    );
1692            }
1693
1694            function rgbString(rgba, alpha) {
1695                if (alpha < 1 || (rgba[3] && rgba[3] < 1)) {
1696                    return rgbaString(rgba, alpha);
1697                }
1698                return "rgb(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2] + ")";
1699            }
1700
1701            function rgbaString(rgba, alpha) {
1702                if (alpha === undefined) {
1703                    alpha = (rgba[3] !== undefined ? rgba[3] : 1);
1704                }
1705                return "rgba(" + rgba[0] + ", " + rgba[1] + ", " + rgba[2]
1706                    + ", " + alpha + ")";
1707            }
1708
1709            function percentString(rgba, alpha) {
1710                if (alpha < 1 || (rgba[3] && rgba[3] < 1)) {
1711                    return percentaString(rgba, alpha);
1712                }
1713                var r = Math.round(rgba[0] / 255 * 100),
1714                    g = Math.round(rgba[1] / 255 * 100),
1715                    b = Math.round(rgba[2] / 255 * 100);
1716
1717                return "rgb(" + r + "%, " + g + "%, " + b + "%)";
1718            }
1719
1720            function percentaString(rgba, alpha) {
1721                var r = Math.round(rgba[0] / 255 * 100),
1722                    g = Math.round(rgba[1] / 255 * 100),
1723                    b = Math.round(rgba[2] / 255 * 100);
1724                return "rgba(" + r + "%, " + g + "%, " + b + "%, " + (alpha || rgba[3] || 1) + ")";
1725            }
1726
1727            function hslString(hsla, alpha) {
1728                if (alpha < 1 || (hsla[3] && hsla[3] < 1)) {
1729                    return hslaString(hsla, alpha);
1730                }
1731                return "hsl(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%)";
1732            }
1733
1734            function hslaString(hsla, alpha) {
1735                if (alpha === undefined) {
1736                    alpha = (hsla[3] !== undefined ? hsla[3] : 1);
1737                }
1738                return "hsla(" + hsla[0] + ", " + hsla[1] + "%, " + hsla[2] + "%, "
1739                    + alpha + ")";
1740            }
1741
1742// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax
1743// (hwb have alpha optional & 1 is default value)
1744            function hwbString(hwb, alpha) {
1745                if (alpha === undefined) {
1746                    alpha = (hwb[3] !== undefined ? hwb[3] : 1);
1747                }
1748                return "hwb(" + hwb[0] + ", " + hwb[1] + "%, " + hwb[2] + "%"
1749                    + (alpha !== undefined && alpha !== 1 ? ", " + alpha : "") + ")";
1750            }
1751
1752            function keyword(rgb) {
1753                return reverseNames[rgb.slice(0, 3)];
1754            }
1755
1756// helpers
1757            function scale(num, min, max) {
1758                return Math.min(Math.max(min, num), max);
1759            }
1760
1761            function hexDouble(num) {
1762                var str = num.toString(16).toUpperCase();
1763                return (str.length < 2) ? "0" + str : str;
1764            }
1765
1766
1767//create a list of reverse color names
1768            var reverseNames = {};
1769            for (var name in colorName$1) {
1770                reverseNames[colorName$1[name]] = name;
1771            }
1772
1773            /* MIT license */
1774
1775
1776            var Color = function (obj) {
1777                if (obj instanceof Color) {
1778                    return obj;
1779                }
1780                if (!(this instanceof Color)) {
1781                    return new Color(obj);
1782                }
1783
1784                this.valid = false;
1785                this.values = {
1786                    rgb: [0, 0, 0],
1787                    hsl: [0, 0, 0],
1788                    hsv: [0, 0, 0],
1789                    hwb: [0, 0, 0],
1790                    cmyk: [0, 0, 0, 0],
1791                    alpha: 1
1792                };
1793
1794                // parse Color() argument
1795                var vals;
1796                if (typeof obj === 'string') {
1797                    vals = colorString.getRgba(obj);
1798                    if (vals) {
1799                        this.setValues('rgb', vals);
1800                    } else if (vals = colorString.getHsla(obj)) {
1801                        this.setValues('hsl', vals);
1802                    } else if (vals = colorString.getHwb(obj)) {
1803                        this.setValues('hwb', vals);
1804                    }
1805                } else if (typeof obj === 'object') {
1806                    vals = obj;
1807                    if (vals.r !== undefined || vals.red !== undefined) {
1808                        this.setValues('rgb', vals);
1809                    } else if (vals.l !== undefined || vals.lightness !== undefined) {
1810                        this.setValues('hsl', vals);
1811                    } else if (vals.v !== undefined || vals.value !== undefined) {
1812                        this.setValues('hsv', vals);
1813                    } else if (vals.w !== undefined || vals.whiteness !== undefined) {
1814                        this.setValues('hwb', vals);
1815                    } else if (vals.c !== undefined || vals.cyan !== undefined) {
1816                        this.setValues('cmyk', vals);
1817                    }
1818                }
1819            };
1820
1821            Color.prototype = {
1822                isValid: function () {
1823                    return this.valid;
1824                },
1825                rgb: function () {
1826                    return this.setSpace('rgb', arguments);
1827                },
1828                hsl: function () {
1829                    return this.setSpace('hsl', arguments);
1830                },
1831                hsv: function () {
1832                    return this.setSpace('hsv', arguments);
1833                },
1834                hwb: function () {
1835                    return this.setSpace('hwb', arguments);
1836                },
1837                cmyk: function () {
1838                    return this.setSpace('cmyk', arguments);
1839                },
1840
1841                rgbArray: function () {
1842                    return this.values.rgb;
1843                },
1844                hslArray: function () {
1845                    return this.values.hsl;
1846                },
1847                hsvArray: function () {
1848                    return this.values.hsv;
1849                },
1850                hwbArray: function () {
1851                    var values = this.values;
1852                    if (values.alpha !== 1) {
1853                        return values.hwb.concat([values.alpha]);
1854                    }
1855                    return values.hwb;
1856                },
1857                cmykArray: function () {
1858                    return this.values.cmyk;
1859                },
1860                rgbaArray: function () {
1861                    var values = this.values;
1862                    return values.rgb.concat([values.alpha]);
1863                },
1864                hslaArray: function () {
1865                    var values = this.values;
1866                    return values.hsl.concat([values.alpha]);
1867                },
1868                alpha: function (val) {
1869                    if (val === undefined) {
1870                        return this.values.alpha;
1871                    }
1872                    this.setValues('alpha', val);
1873                    return this;
1874                },
1875
1876                red: function (val) {
1877                    return this.setChannel('rgb', 0, val);
1878                },
1879                green: function (val) {
1880                    return this.setChannel('rgb', 1, val);
1881                },
1882                blue: function (val) {
1883                    return this.setChannel('rgb', 2, val);
1884                },
1885                hue: function (val) {
1886                    if (val) {
1887                        val %= 360;
1888                        val = val < 0 ? 360 + val : val;
1889                    }
1890                    return this.setChannel('hsl', 0, val);
1891                },
1892                saturation: function (val) {
1893                    return this.setChannel('hsl', 1, val);
1894                },
1895                lightness: function (val) {
1896                    return this.setChannel('hsl', 2, val);
1897                },
1898                saturationv: function (val) {
1899                    return this.setChannel('hsv', 1, val);
1900                },
1901                whiteness: function (val) {
1902                    return this.setChannel('hwb', 1, val);
1903                },
1904                blackness: function (val) {
1905                    return this.setChannel('hwb', 2, val);
1906                },
1907                value: function (val) {
1908                    return this.setChannel('hsv', 2, val);
1909                },
1910                cyan: function (val) {
1911                    return this.setChannel('cmyk', 0, val);
1912                },
1913                magenta: function (val) {
1914                    return this.setChannel('cmyk', 1, val);
1915                },
1916                yellow: function (val) {
1917                    return this.setChannel('cmyk', 2, val);
1918                },
1919                black: function (val) {
1920                    return this.setChannel('cmyk', 3, val);
1921                },
1922
1923                hexString: function () {
1924                    return colorString.hexString(this.values.rgb);
1925                },
1926                rgbString: function () {
1927                    return colorString.rgbString(this.values.rgb, this.values.alpha);
1928                },
1929                rgbaString: function () {
1930                    return colorString.rgbaString(this.values.rgb, this.values.alpha);
1931                },
1932                percentString: function () {
1933                    return colorString.percentString(this.values.rgb, this.values.alpha);
1934                },
1935                hslString: function () {
1936                    return colorString.hslString(this.values.hsl, this.values.alpha);
1937                },
1938                hslaString: function () {
1939                    return colorString.hslaString(this.values.hsl, this.values.alpha);
1940                },
1941                hwbString: function () {
1942                    return colorString.hwbString(this.values.hwb, this.values.alpha);
1943                },
1944                keyword: function () {
1945                    return colorString.keyword(this.values.rgb, this.values.alpha);
1946                },
1947
1948                rgbNumber: function () {
1949                    var rgb = this.values.rgb;
1950                    return (rgb[0] << 16) | (rgb[1] << 8) | rgb[2];
1951                },
1952
1953                luminosity: function () {
1954                    // http://www.w3.org/TR/WCAG20/#relativeluminancedef
1955                    var rgb = this.values.rgb;
1956                    var lum = [];
1957                    for (var i = 0; i < rgb.length; i++) {
1958                        var chan = rgb[i] / 255;
1959                        lum[i] = (chan <= 0.03928) ? chan / 12.92 : Math.pow(((chan + 0.055) / 1.055), 2.4);
1960                    }
1961                    return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
1962                },
1963
1964                contrast: function (color2) {
1965                    // http://www.w3.org/TR/WCAG20/#contrast-ratiodef
1966                    var lum1 = this.luminosity();
1967                    var lum2 = color2.luminosity();
1968                    if (lum1 > lum2) {
1969                        return (lum1 + 0.05) / (lum2 + 0.05);
1970                    }
1971                    return (lum2 + 0.05) / (lum1 + 0.05);
1972                },
1973
1974                level: function (color2) {
1975                    var contrastRatio = this.contrast(color2);
1976                    if (contrastRatio >= 7.1) {
1977                        return 'AAA';
1978                    }
1979
1980                    return (contrastRatio >= 4.5) ? 'AA' : '';
1981                },
1982
1983                dark: function () {
1984                    // YIQ equation from http://24ways.org/2010/calculating-color-contrast
1985                    var rgb = this.values.rgb;
1986                    var yiq = (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1000;
1987                    return yiq < 128;
1988                },
1989
1990                light: function () {
1991                    return !this.dark();
1992                },
1993
1994                negate: function () {
1995                    var rgb = [];
1996                    for (var i = 0; i < 3; i++) {
1997                        rgb[i] = 255 - this.values.rgb[i];
1998                    }
1999                    this.setValues('rgb', rgb);
2000                    return this;
2001                },
2002
2003                lighten: function (ratio) {
2004                    var hsl = this.values.hsl;
2005                    hsl[2] += hsl[2] * ratio;
2006                    this.setValues('hsl', hsl);
2007                    return this;
2008                },
2009
2010                darken: function (ratio) {
2011                    var hsl = this.values.hsl;
2012                    hsl[2] -= hsl[2] * ratio;
2013                    this.setValues('hsl', hsl);
2014                    return this;
2015                },
2016
2017                saturate: function (ratio) {
2018                    var hsl = this.values.hsl;
2019                    hsl[1] += hsl[1] * ratio;
2020                    this.setValues('hsl', hsl);
2021                    return this;
2022                },
2023
2024                desaturate: function (ratio) {
2025                    var hsl = this.values.hsl;
2026                    hsl[1] -= hsl[1] * ratio;
2027                    this.setValues('hsl', hsl);
2028                    return this;
2029                },
2030
2031                whiten: function (ratio) {
2032                    var hwb = this.values.hwb;
2033                    hwb[1] += hwb[1] * ratio;
2034                    this.setValues('hwb', hwb);
2035                    return this;
2036                },
2037
2038                blacken: function (ratio) {
2039                    var hwb = this.values.hwb;
2040                    hwb[2] += hwb[2] * ratio;
2041                    this.setValues('hwb', hwb);
2042                    return this;
2043                },
2044
2045                greyscale: function () {
2046                    var rgb = this.values.rgb;
2047                    // http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale
2048                    var val = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
2049                    this.setValues('rgb', [val, val, val]);
2050                    return this;
2051                },
2052
2053                clearer: function (ratio) {
2054                    var alpha = this.values.alpha;
2055                    this.setValues('alpha', alpha - (alpha * ratio));
2056                    return this;
2057                },
2058
2059                opaquer: function (ratio) {
2060                    var alpha = this.values.alpha;
2061                    this.setValues('alpha', alpha + (alpha * ratio));
2062                    return this;
2063                },
2064
2065                rotate: function (degrees) {
2066                    var hsl = this.values.hsl;
2067                    var hue = (hsl[0] + degrees) % 360;
2068                    hsl[0] = hue < 0 ? 360 + hue : hue;
2069                    this.setValues('hsl', hsl);
2070                    return this;
2071                },
2072
2073                /**
2074                 * Ported from sass implementation in C
2075                 * https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209
2076                 */
2077                mix: function (mixinColor, weight) {
2078                    var color1 = this;
2079                    var color2 = mixinColor;
2080                    var p = weight === undefined ? 0.5 : weight;
2081
2082                    var w = 2 * p - 1;
2083                    var a = color1.alpha() - color2.alpha();
2084
2085                    var w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
2086                    var w2 = 1 - w1;
2087
2088                    return this
2089                        .rgb(
2090                            w1 * color1.red() + w2 * color2.red(),
2091                            w1 * color1.green() + w2 * color2.green(),
2092                            w1 * color1.blue() + w2 * color2.blue()
2093                        )
2094                        .alpha(color1.alpha() * p + color2.alpha() * (1 - p));
2095                },
2096
2097                toJSON: function () {
2098                    return this.rgb();
2099                },
2100
2101                clone: function () {
2102                    // NOTE(SB): using node-clone creates a dependency to Buffer when using browserify,
2103                    // making the final build way to big to embed in Chart.js. So let's do it manually,
2104                    // assuming that values to clone are 1 dimension arrays containing only numbers,
2105                    // except 'alpha' which is a number.
2106                    var result = new Color();
2107                    var source = this.values;
2108                    var target = result.values;
2109                    var value, type;
2110
2111                    for (var prop in source) {
2112                        if (source.hasOwnProperty(prop)) {
2113                            value = source[prop];
2114                            type = ({}).toString.call(value);
2115                            if (type === '[object Array]') {
2116                                target[prop] = value.slice(0);
2117                            } else if (type === '[object Number]') {
2118                                target[prop] = value;
2119                            } else {
2120                                console.error('unexpected color value:', value);
2121                            }
2122                        }
2123                    }
2124
2125                    return result;
2126                }
2127            };
2128
2129            Color.prototype.spaces = {
2130                rgb: ['red', 'green', 'blue'],
2131                hsl: ['hue', 'saturation', 'lightness'],
2132                hsv: ['hue', 'saturation', 'value'],
2133                hwb: ['hue', 'whiteness', 'blackness'],
2134                cmyk: ['cyan', 'magenta', 'yellow', 'black']
2135            };
2136
2137            Color.prototype.maxes = {
2138                rgb: [255, 255, 255],
2139                hsl: [360, 100, 100],
2140                hsv: [360, 100, 100],
2141                hwb: [360, 100, 100],
2142                cmyk: [100, 100, 100, 100]
2143            };
2144
2145            Color.prototype.getValues = function (space) {
2146                var values = this.values;
2147                var vals = {};
2148
2149                for (var i = 0; i < space.length; i++) {
2150                    vals[space.charAt(i)] = values[space][i];
2151                }
2152
2153                if (values.alpha !== 1) {
2154                    vals.a = values.alpha;
2155                }
2156
2157                // {r: 255, g: 255, b: 255, a: 0.4}
2158                return vals;
2159            };
2160
2161            Color.prototype.setValues = function (space, vals) {
2162                var values = this.values;
2163                var spaces = this.spaces;
2164                var maxes = this.maxes;
2165                var alpha = 1;
2166                var i;
2167
2168                this.valid = true;
2169
2170                if (space === 'alpha') {
2171                    alpha = vals;
2172                } else if (vals.length) {
2173                    // [10, 10, 10]
2174                    values[space] = vals.slice(0, space.length);
2175                    alpha = vals[space.length];
2176                } else if (vals[space.charAt(0)] !== undefined) {
2177                    // {r: 10, g: 10, b: 10}
2178                    for (i = 0; i < space.length; i++) {
2179                        values[space][i] = vals[space.charAt(i)];
2180                    }
2181
2182                    alpha = vals.a;
2183                } else if (vals[spaces[space][0]] !== undefined) {
2184                    // {red: 10, green: 10, blue: 10}
2185                    var chans = spaces[space];
2186
2187                    for (i = 0; i < space.length; i++) {
2188                        values[space][i] = vals[chans[i]];
2189                    }
2190
2191                    alpha = vals.alpha;
2192                }
2193
2194                values.alpha = Math.max(0, Math.min(1, (alpha === undefined ? values.alpha : alpha)));
2195
2196                if (space === 'alpha') {
2197                    return false;
2198                }
2199
2200                var capped;
2201
2202                // cap values of the space prior converting all values
2203                for (i = 0; i < space.length; i++) {
2204                    capped = Math.max(0, Math.min(maxes[space][i], values[space][i]));
2205                    values[space][i] = Math.round(capped);
2206                }
2207
2208                // convert to all the other color spaces
2209                for (var sname in spaces) {
2210                    if (sname !== space) {
2211                        values[sname] = colorConvert[space][sname](values[space]);
2212                    }
2213                }
2214
2215                return true;
2216            };
2217
2218            Color.prototype.setSpace = function (space, args) {
2219                var vals = args[0];
2220
2221                if (vals === undefined) {
2222                    // color.rgb()
2223                    return this.getValues(space);
2224                }
2225
2226                // color.rgb(10, 10, 10)
2227                if (typeof vals === 'number') {
2228                    vals = Array.prototype.slice.call(args);
2229                }
2230
2231                this.setValues(space, vals);
2232                return this;
2233            };
2234
2235            Color.prototype.setChannel = function (space, index, val) {
2236                var svalues = this.values[space];
2237                if (val === undefined) {
2238                    // color.red()
2239                    return svalues[index];
2240                } else if (val === svalues[index]) {
2241                    // color.red(color.red())
2242                    return this;
2243                }
2244
2245                // color.red(100)
2246                svalues[index] = val;
2247                this.setValues(space, svalues);
2248
2249                return this;
2250            };
2251
2252            if (typeof window !== 'undefined') {
2253                window.Color = Color;
2254            }
2255
2256            var chartjsColor = Color;
2257
2258            function isValidKey(key) {
2259                return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1;
2260            }
2261
2262            /**
2263             * @namespace Chart.helpers
2264             */
2265            var helpers = {
2266                /**
2267                 * An empty function that can be used, for example, for optional callback.
2268                 */
2269                noop: function () {
2270                },
2271
2272                /**
2273                 * Returns a unique id, sequentially generated from a global variable.
2274                 * @returns {number}
2275                 * @function
2276                 */
2277                uid: (function () {
2278                    var id = 0;
2279                    return function () {
2280                        return id++;
2281                    };
2282                }()),
2283
2284                /**
2285                 * Returns true if `value` is neither null nor undefined, else returns false.
2286                 * @param {*} value - The value to test.
2287                 * @returns {boolean}
2288                 * @since 2.7.0
2289                 */
2290                isNullOrUndef: function (value) {
2291                    return value === null || typeof value === 'undefined';
2292                },
2293
2294                /**
2295                 * Returns true if `value` is an array (including typed arrays), else returns false.
2296                 * @param {*} value - The value to test.
2297                 * @returns {boolean}
2298                 * @function
2299                 */
2300                isArray: function (value) {
2301                    if (Array.isArray && Array.isArray(value)) {
2302                        return true;
2303                    }
2304                    var type = Object.prototype.toString.call(value);
2305                    if (type.substr(0, 7) === '[object' && type.substr(-6) === 'Array]') {
2306                        return true;
2307                    }
2308                    return false;
2309                },
2310
2311                /**
2312                 * Returns true if `value` is an object (excluding null), else returns false.
2313                 * @param {*} value - The value to test.
2314                 * @returns {boolean}
2315                 * @since 2.7.0
2316                 */
2317                isObject: function (value) {
2318                    return value !== null && Object.prototype.toString.call(value) === '[object Object]';
2319                },
2320
2321                /**
2322                 * Returns true if `value` is a finite number, else returns false
2323                 * @param {*} value  - The value to test.
2324                 * @returns {boolean}
2325                 */
2326                isFinite: function (value) {
2327                    return (typeof value === 'number' || value instanceof Number) && isFinite(value);
2328                },
2329
2330                /**
2331                 * Returns `value` if defined, else returns `defaultValue`.
2332                 * @param {*} value - The value to return if defined.
2333                 * @param {*} defaultValue - The value to return if `value` is undefined.
2334                 * @returns {*}
2335                 */
2336                valueOrDefault: function (value, defaultValue) {
2337                    return typeof value === 'undefined' ? defaultValue : value;
2338                },
2339
2340                /**
2341                 * Returns value at the given `index` in array if defined, else returns `defaultValue`.
2342                 * @param {Array} value - The array to lookup for value at `index`.
2343                 * @param {number} index - The index in `value` to lookup for value.
2344                 * @param {*} defaultValue - The value to return if `value[index]` is undefined.
2345                 * @returns {*}
2346                 */
2347                valueAtIndexOrDefault: function (value, index, defaultValue) {
2348                    return helpers.valueOrDefault(helpers.isArray(value) ? value[index] : value, defaultValue);
2349                },
2350
2351                /**
2352                 * Calls `fn` with the given `args` in the scope defined by `thisArg` and returns the
2353                 * value returned by `fn`. If `fn` is not a function, this method returns undefined.
2354                 * @param {function} fn - The function to call.
2355                 * @param {Array|undefined|null} args - The arguments with which `fn` should be called.
2356                 * @param {object} [thisArg] - The value of `this` provided for the call to `fn`.
2357                 * @returns {*}
2358                 */
2359                callback: function (fn, args, thisArg) {
2360                    if (fn && typeof fn.call === 'function') {
2361                        return fn.apply(thisArg, args);
2362                    }
2363                },
2364
2365                /**
2366                 * Note(SB) for performance sake, this method should only be used when loopable type
2367                 * is unknown or in none intensive code (not called often and small loopable). Else
2368                 * it's preferable to use a regular for() loop and save extra function calls.
2369                 * @param {object|Array} loopable - The object or array to be iterated.
2370                 * @param {function} fn - The function to call for each item.
2371                 * @param {object} [thisArg] - The value of `this` provided for the call to `fn`.
2372                 * @param {boolean} [reverse] - If true, iterates backward on the loopable.
2373                 */
2374                each: function (loopable, fn, thisArg, reverse) {
2375                    var i, len, keys;
2376                    if (helpers.isArray(loopable)) {
2377                        len = loopable.length;
2378                        if (reverse) {
2379                            for (i = len - 1; i >= 0; i--) {
2380                                fn.call(thisArg, loopable[i], i);
2381                            }
2382                        } else {
2383                            for (i = 0; i < len; i++) {
2384                                fn.call(thisArg, loopable[i], i);
2385                            }
2386                        }
2387                    } else if (helpers.isObject(loopable)) {
2388                        keys = Object.keys(loopable);
2389                        len = keys.length;
2390                        for (i = 0; i < len; i++) {
2391                            fn.call(thisArg, loopable[keys[i]], keys[i]);
2392                        }
2393                    }
2394                },
2395
2396                /**
2397                 * Returns true if the `a0` and `a1` arrays have the same content, else returns false.
2398                 * @see https://stackoverflow.com/a/14853974
2399                 * @param {Array} a0 - The array to compare
2400                 * @param {Array} a1 - The array to compare
2401                 * @returns {boolean}
2402                 */
2403                arrayEquals: function (a0, a1) {
2404                    var i, ilen, v0, v1;
2405
2406                    if (!a0 || !a1 || a0.length !== a1.length) {
2407                        return false;
2408                    }
2409
2410                    for (i = 0, ilen = a0.length; i < ilen; ++i) {
2411                        v0 = a0[i];
2412                        v1 = a1[i];
2413
2414                        if (v0 instanceof Array && v1 instanceof Array) {
2415                            if (!helpers.arrayEquals(v0, v1)) {
2416                                return false;
2417                            }
2418                        } else if (v0 !== v1) {
2419                            // NOTE: two different object instances will never be equal: {x:20} != {x:20}
2420                            return false;
2421                        }
2422                    }
2423
2424                    return true;
2425                },
2426
2427                /**
2428                 * Returns a deep copy of `source` without keeping references on objects and arrays.
2429                 * @param {*} source - The value to clone.
2430                 * @returns {*}
2431                 */
2432                clone: function (source) {
2433                    if (helpers.isArray(source)) {
2434                        return source.map(helpers.clone);
2435                    }
2436
2437                    if (helpers.isObject(source)) {
2438                        var target = Object.create(source);
2439                        var keys = Object.keys(source);
2440                        var klen = keys.length;
2441                        var k = 0;
2442
2443                        for (; k < klen; ++k) {
2444                            target[keys[k]] = helpers.clone(source[keys[k]]);
2445                        }
2446
2447                        return target;
2448                    }
2449
2450                    return source;
2451                },
2452
2453                /**
2454                 * The default merger when Chart.helpers.merge is called without merger option.
2455                 * Note(SB): also used by mergeConfig and mergeScaleConfig as fallback.
2456                 * @private
2457                 */
2458                _merger: function (key, target, source, options) {
2459                    if (!isValidKey(key)) {
2460                        // We want to ensure we do not copy prototypes over
2461                        // as this can pollute global namespaces
2462                        return;
2463                    }
2464
2465                    var tval = target[key];
2466                    var sval = source[key];
2467
2468                    if (helpers.isObject(tval) && helpers.isObject(sval)) {
2469                        helpers.merge(tval, sval, options);
2470                    } else {
2471                        target[key] = helpers.clone(sval);
2472                    }
2473                },
2474
2475                /**
2476                 * Merges source[key] in target[key] only if target[key] is undefined.
2477                 * @private
2478                 */
2479                _mergerIf: function (key, target, source) {
2480                    if (!isValidKey(key)) {
2481                        // We want to ensure we do not copy prototypes over
2482                        // as this can pollute global namespaces
2483                        return;
2484                    }
2485
2486                    var tval = target[key];
2487                    var sval = source[key];
2488
2489                    if (helpers.isObject(tval) && helpers.isObject(sval)) {
2490                        helpers.mergeIf(tval, sval);
2491                    } else if (!target.hasOwnProperty(key)) {
2492                        target[key] = helpers.clone(sval);
2493                    }
2494                },
2495
2496                /**
2497                 * Recursively deep copies `source` properties into `target` with the given `options`.
2498                 * IMPORTANT: `target` is not cloned and will be updated with `source` properties.
2499                 * @param {object} target - The target object in which all sources are merged into.
2500                 * @param {object|object[]} source - Object(s) to merge into `target`.
2501                 * @param {object} [options] - Merging options:
2502                 * @param {function} [options.merger] - The merge method (key, target, source, options)
2503                 * @returns {object} The `target` object.
2504                 */
2505                merge: function (target, source, options) {
2506                    var sources = helpers.isArray(source) ? source : [source];
2507                    var ilen = sources.length;
2508                    var merge, i, keys, klen, k;
2509
2510                    if (!helpers.isObject(target)) {
2511                        return target;
2512                    }
2513
2514                    options = options || {};
2515                    merge = options.merger || helpers._merger;
2516
2517                    for (i = 0; i < ilen; ++i) {
2518                        source = sources[i];
2519                        if (!helpers.isObject(source)) {
2520                            continue;
2521                        }
2522
2523                        keys = Object.keys(source);
2524                        for (k = 0, klen = keys.length; k < klen; ++k) {
2525                            merge(keys[k], target, source, options);
2526                        }
2527                    }
2528
2529                    return target;
2530                },
2531
2532                /**
2533                 * Recursively deep copies `source` properties into `target` *only* if not defined in target.
2534                 * IMPORTANT: `target` is not cloned and will be updated with `source` properties.
2535                 * @param {object} target - The target object in which all sources are merged into.
2536                 * @param {object|object[]} source - Object(s) to merge into `target`.
2537                 * @returns {object} The `target` object.
2538                 */
2539                mergeIf: function (target, source) {
2540                    return helpers.merge(target, source, {merger: helpers._mergerIf});
2541                },
2542
2543                /**
2544                 * Applies the contents of two or more objects together into the first object.
2545                 * @param {object} target - The target object in which all objects are merged into.
2546                 * @param {object} arg1 - Object containing additional properties to merge in target.
2547                 * @param {object} argN - Additional objects containing properties to merge in target.
2548                 * @returns {object} The `target` object.
2549                 */
2550                extend: Object.assign || function (target) {
2551                    return helpers.merge(target, [].slice.call(arguments, 1), {
2552                        merger: function (key, dst, src) {
2553                            dst[key] = src[key];
2554                        }
2555                    });
2556                },
2557
2558                /**
2559                 * Basic javascript inheritance based on the model created in Backbone.js
2560                 */
2561                inherits: function (extensions) {
2562                    var me = this;
2563                    var ChartElement = (extensions && extensions.hasOwnProperty('constructor')) ? extensions.constructor : function () {
2564                        return me.apply(this, arguments);
2565                    };
2566
2567                    var Surrogate = function () {
2568                        this.constructor = ChartElement;
2569                    };
2570
2571                    Surrogate.prototype = me.prototype;
2572                    ChartElement.prototype = new Surrogate();
2573                    ChartElement.extend = helpers.inherits;
2574
2575                    if (extensions) {
2576                        helpers.extend(ChartElement.prototype, extensions);
2577                    }
2578
2579                    ChartElement.__super__ = me.prototype;
2580                    return ChartElement;
2581                },
2582
2583                _deprecated: function (scope, value, previous, current) {
2584                    if (value !== undefined) {
2585                        console.warn(scope + ': "' + previous +
2586                            '" is deprecated. Please use "' + current + '" instead');
2587                    }
2588                }
2589            };
2590
2591            var helpers_core = helpers;
2592
2593// DEPRECATIONS
2594
2595            /**
2596             * Provided for backward compatibility, use Chart.helpers.callback instead.
2597             * @function Chart.helpers.callCallback
2598             * @deprecated since version 2.6.0
2599             * @todo remove at version 3
2600             * @private
2601             */
2602            helpers.callCallback = helpers.callback;
2603
2604            /**
2605             * Provided for backward compatibility, use Array.prototype.indexOf instead.
2606             * Array.prototype.indexOf compatibility: Chrome, Opera, Safari, FF1.5+, IE9+
2607             * @function Chart.helpers.indexOf
2608             * @deprecated since version 2.7.0
2609             * @todo remove at version 3
2610             * @private
2611             */
2612            helpers.indexOf = function (array, item, fromIndex) {
2613                return Array.prototype.indexOf.call(array, item, fromIndex);
2614            };
2615
2616            /**
2617             * Provided for backward compatibility, use Chart.helpers.valueOrDefault instead.
2618             * @function Chart.helpers.getValueOrDefault
2619             * @deprecated since version 2.7.0
2620             * @todo remove at version 3
2621             * @private
2622             */
2623            helpers.getValueOrDefault = helpers.valueOrDefault;
2624
2625            /**
2626             * Provided for backward compatibility, use Chart.helpers.valueAtIndexOrDefault instead.
2627             * @function Chart.helpers.getValueAtIndexOrDefault
2628             * @deprecated since version 2.7.0
2629             * @todo remove at version 3
2630             * @private
2631             */
2632            helpers.getValueAtIndexOrDefault = helpers.valueAtIndexOrDefault;
2633
2634            /**
2635             * Easing functions adapted from Robert Penner's easing equations.
2636             * @namespace Chart.helpers.easingEffects
2637             * @see http://www.robertpenner.com/easing/
2638             */
2639            var effects = {
2640                linear: function (t) {
2641                    return t;
2642                },
2643
2644                easeInQuad: function (t) {
2645                    return t * t;
2646                },
2647
2648                easeOutQuad: function (t) {
2649                    return -t * (t - 2);
2650                },
2651
2652                easeInOutQuad: function (t) {
2653                    if ((t /= 0.5) < 1) {
2654                        return 0.5 * t * t;
2655                    }
2656                    return -0.5 * ((--t) * (t - 2) - 1);
2657                },
2658
2659                easeInCubic: function (t) {
2660                    return t * t * t;
2661                },
2662
2663                easeOutCubic: function (t) {
2664                    return (t = t - 1) * t * t + 1;
2665                },
2666
2667                easeInOutCubic: function (t) {
2668                    if ((t /= 0.5) < 1) {
2669                        return 0.5 * t * t * t;
2670                    }
2671                    return 0.5 * ((t -= 2) * t * t + 2);
2672                },
2673
2674                easeInQuart: function (t) {
2675                    return t * t * t * t;
2676                },
2677
2678                easeOutQuart: function (t) {
2679                    return -((t = t - 1) * t * t * t - 1);
2680                },
2681
2682                easeInOutQuart: function (t) {
2683                    if ((t /= 0.5) < 1) {
2684                        return 0.5 * t * t * t * t;
2685                    }
2686                    return -0.5 * ((t -= 2) * t * t * t - 2);
2687                },
2688
2689                easeInQuint: function (t) {
2690                    return t * t * t * t * t;
2691                },
2692
2693                easeOutQuint: function (t) {
2694                    return (t = t - 1) * t * t * t * t + 1;
2695                },
2696
2697                easeInOutQuint: function (t) {
2698                    if ((t /= 0.5) < 1) {
2699                        return 0.5 * t * t * t * t * t;
2700                    }
2701                    return 0.5 * ((t -= 2) * t * t * t * t + 2);
2702                },
2703
2704                easeInSine: function (t) {
2705                    return -Math.cos(t * (Math.PI / 2)) + 1;
2706                },
2707
2708                easeOutSine: function (t) {
2709                    return Math.sin(t * (Math.PI / 2));
2710                },
2711
2712                easeInOutSine: function (t) {
2713                    return -0.5 * (Math.cos(Math.PI * t) - 1);
2714                },
2715
2716                easeInExpo: function (t) {
2717                    return (t === 0) ? 0 : Math.pow(2, 10 * (t - 1));
2718                },
2719
2720                easeOutExpo: function (t) {
2721                    return (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1;
2722                },
2723
2724                easeInOutExpo: function (t) {
2725                    if (t === 0) {
2726                        return 0;
2727                    }
2728                    if (t === 1) {
2729                        return 1;
2730                    }
2731                    if ((t /= 0.5) < 1) {
2732                        return 0.5 * Math.pow(2, 10 * (t - 1));
2733                    }
2734                    return 0.5 * (-Math.pow(2, -10 * --t) + 2);
2735                },
2736
2737                easeInCirc: function (t) {
2738                    if (t >= 1) {
2739                        return t;
2740                    }
2741                    return -(Math.sqrt(1 - t * t) - 1);
2742                },
2743
2744                easeOutCirc: function (t) {
2745                    return Math.sqrt(1 - (t = t - 1) * t);
2746                },
2747
2748                easeInOutCirc: function (t) {
2749                    if ((t /= 0.5) < 1) {
2750                        return -0.5 * (Math.sqrt(1 - t * t) - 1);
2751                    }
2752                    return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1);
2753                },
2754
2755                easeInElastic: function (t) {
2756                    var s = 1.70158;
2757                    var p = 0;
2758                    var a = 1;
2759                    if (t === 0) {
2760                        return 0;
2761                    }
2762                    if (t === 1) {
2763                        return 1;
2764                    }
2765                    if (!p) {
2766                        p = 0.3;
2767                    }
2768                    if (a < 1) {
2769                        a = 1;
2770                        s = p / 4;
2771                    } else {
2772                        s = p / (2 * Math.PI) * Math.asin(1 / a);
2773                    }
2774                    return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p));
2775                },
2776
2777                easeOutElastic: function (t) {
2778                    var s = 1.70158;
2779                    var p = 0;
2780                    var a = 1;
2781                    if (t === 0) {
2782                        return 0;
2783                    }
2784                    if (t === 1) {
2785                        return 1;
2786                    }
2787                    if (!p) {
2788                        p = 0.3;
2789                    }
2790                    if (a < 1) {
2791                        a = 1;
2792                        s = p / 4;
2793                    } else {
2794                        s = p / (2 * Math.PI) * Math.asin(1 / a);
2795                    }
2796                    return a * Math.pow(2, -10 * t) * Math.sin((t - s) * (2 * Math.PI) / p) + 1;
2797                },
2798
2799                easeInOutElastic: function (t) {
2800                    var s = 1.70158;
2801                    var p = 0;
2802                    var a = 1;
2803                    if (t === 0) {
2804                        return 0;
2805                    }
2806                    if ((t /= 0.5) === 2) {
2807                        return 1;
2808                    }
2809                    if (!p) {
2810                        p = 0.45;
2811                    }
2812                    if (a < 1) {
2813                        a = 1;
2814                        s = p / 4;
2815                    } else {
2816                        s = p / (2 * Math.PI) * Math.asin(1 / a);
2817                    }
2818                    if (t < 1) {
2819                        return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p));
2820                    }
2821                    return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t - s) * (2 * Math.PI) / p) * 0.5 + 1;
2822                },
2823                easeInBack: function (t) {
2824                    var s = 1.70158;
2825                    return t * t * ((s + 1) * t - s);
2826                },
2827
2828                easeOutBack: function (t) {
2829                    var s = 1.70158;
2830                    return (t = t - 1) * t * ((s + 1) * t + s) + 1;
2831                },
2832
2833                easeInOutBack: function (t) {
2834                    var s = 1.70158;
2835                    if ((t /= 0.5) < 1) {
2836                        return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s));
2837                    }
2838                    return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2);
2839                },
2840
2841                easeInBounce: function (t) {
2842                    return 1 - effects.easeOutBounce(1 - t);
2843                },
2844
2845                easeOutBounce: function (t) {
2846                    if (t < (1 / 2.75)) {
2847                        return 7.5625 * t * t;
2848                    }
2849                    if (t < (2 / 2.75)) {
2850                        return 7.5625 * (t -= (1.5 / 2.75)) * t + 0.75;
2851                    }
2852                    if (t < (2.5 / 2.75)) {
2853                        return 7.5625 * (t -= (2.25 / 2.75)) * t + 0.9375;
2854                    }
2855                    return 7.5625 * (t -= (2.625 / 2.75)) * t + 0.984375;
2856                },
2857
2858                easeInOutBounce: function (t) {
2859                    if (t < 0.5) {
2860                        return effects.easeInBounce(t * 2) * 0.5;
2861                    }
2862                    return effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5;
2863                }
2864            };
2865
2866            var helpers_easing = {
2867                effects: effects
2868            };
2869
2870// DEPRECATIONS
2871
2872            /**
2873             * Provided for backward compatibility, use Chart.helpers.easing.effects instead.
2874             * @function Chart.helpers.easingEffects
2875             * @deprecated since version 2.7.0
2876             * @todo remove at version 3
2877             * @private
2878             */
2879            helpers_core.easingEffects = effects;
2880
2881            var PI = Math.PI;
2882            var RAD_PER_DEG = PI / 180;
2883            var DOUBLE_PI = PI * 2;
2884            var HALF_PI = PI / 2;
2885            var QUARTER_PI = PI / 4;
2886            var TWO_THIRDS_PI = PI * 2 / 3;
2887
2888            /**
2889             * @namespace Chart.helpers.canvas
2890             */
2891            var exports$1 = {
2892                /**
2893                 * Clears the entire canvas associated to the given `chart`.
2894                 * @param {Chart} chart - The chart for which to clear the canvas.
2895                 */
2896                clear: function (chart) {
2897                    chart.ctx.clearRect(0, 0, chart.width, chart.height);
2898                },
2899
2900                /**
2901                 * Creates a "path" for a rectangle with rounded corners at position (x, y) with a
2902                 * given size (width, height) and the same `radius` for all corners.
2903                 * @param {CanvasRenderingContext2D} ctx - The canvas 2D Context.
2904                 * @param {number} x - The x axis of the coordinate for the rectangle starting point.
2905                 * @param {number} y - The y axis of the coordinate for the rectangle starting point.
2906                 * @param {number} width - The rectangle's width.
2907                 * @param {number} height - The rectangle's height.
2908                 * @param {number} radius - The rounded amount (in pixels) for the four corners.
2909                 * @todo handle `radius` as top-left, top-right, bottom-right, bottom-left array/object?
2910                 */
2911                roundedRect: function (ctx, x, y, width, height, radius) {
2912                    if (radius) {
2913                        var r = Math.min(radius, height / 2, width / 2);
2914                        var left = x + r;
2915                        var top = y + r;
2916                        var right = x + width - r;
2917                        var bottom = y + height - r;
2918
2919                        ctx.moveTo(x, top);
2920                        if (left < right && top < bottom) {
2921                            ctx.arc(left, top, r, -PI, -HALF_PI);
2922                            ctx.arc(right, top, r, -HALF_PI, 0);
2923                            ctx.arc(right, bottom, r, 0, HALF_PI);
2924                            ctx.arc(left, bottom, r, HALF_PI, PI);
2925                        } else if (left < right) {
2926                            ctx.moveTo(left, y);
2927                            ctx.arc(right, top, r, -HALF_PI, HALF_PI);
2928                            ctx.arc(left, top, r, HALF_PI, PI + HALF_PI);
2929                        } else if (top < bottom) {
2930                            ctx.arc(left, top, r, -PI, 0);
2931                            ctx.arc(left, bottom, r, 0, PI);
2932                        } else {
2933                            ctx.arc(left, top, r, -PI, PI);
2934                        }
2935                        ctx.closePath();
2936                        ctx.moveTo(x, y);
2937                    } else {
2938                        ctx.rect(x, y, width, height);
2939                    }
2940                },
2941
2942                drawPoint: function (ctx, style, radius, x, y, rotation) {
2943                    var type, xOffset, yOffset, size, cornerRadius;
2944                    var rad = (rotation || 0) * RAD_PER_DEG;
2945
2946                    if (style && typeof style === 'object') {
2947                        type = style.toString();
2948                        if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {
2949                            ctx.save();
2950                            ctx.translate(x, y);
2951                            ctx.rotate(rad);
2952                            ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);
2953                            ctx.restore();
2954                            return;
2955                        }
2956                    }
2957
2958                    if (isNaN(radius) || radius <= 0) {
2959                        return;
2960                    }
2961
2962                    ctx.beginPath();
2963
2964                    switch (style) {
2965                        // Default includes circle
2966                        default:
2967                            ctx.arc(x, y, radius, 0, DOUBLE_PI);
2968                            ctx.closePath();
2969                            break;
2970                        case 'triangle':
2971                            ctx.moveTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
2972                            rad += TWO_THIRDS_PI;
2973                            ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
2974                            rad += TWO_THIRDS_PI;
2975                            ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
2976                            ctx.closePath();
2977                            break;
2978                        case 'rectRounded':
2979                            // NOTE: the rounded rect implementation changed to use `arc` instead of
2980                            // `quadraticCurveTo` since it generates better results when rect is
2981                            // almost a circle. 0.516 (instead of 0.5) produces results with visually
2982                            // closer proportion to the previous impl and it is inscribed in the
2983                            // circle with `radius`. For more details, see the following PRs:
2984                            // https://github.com/chartjs/Chart.js/issues/5597
2985                            // https://github.com/chartjs/Chart.js/issues/5858
2986                            cornerRadius = radius * 0.516;
2987                            size = radius - cornerRadius;
2988                            xOffset = Math.cos(rad + QUARTER_PI) * size;
2989                            yOffset = Math.sin(rad + QUARTER_PI) * size;
2990                            ctx.arc(x - xOffset, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI);
2991                            ctx.arc(x + yOffset, y - xOffset, cornerRadius, rad - HALF_PI, rad);
2992                            ctx.arc(x + xOffset, y + yOffset, cornerRadius, rad, rad + HALF_PI);
2993                            ctx.arc(x - yOffset, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI);
2994                            ctx.closePath();
2995                            break;
2996                        case 'rect':
2997                            if (!rotation) {
2998                                size = Math.SQRT1_2 * radius;
2999                                ctx.rect(x - size, y - size, 2 * size, 2 * size);
3000                                break;
3001                            }
3002                            rad += QUARTER_PI;
3003                        /* falls through */
3004                        case 'rectRot':
3005                            xOffset = Math.cos(rad) * radius;
3006                            yOffset = Math.sin(rad) * radius;
3007                            ctx.moveTo(x - xOffset, y - yOffset);
3008                            ctx.lineTo(x + yOffset, y - xOffset);
3009                            ctx.lineTo(x + xOffset, y + yOffset);
3010                            ctx.lineTo(x - yOffset, y + xOffset);
3011                            ctx.closePath();
3012                            break;
3013                        case 'crossRot':
3014                            rad += QUARTER_PI;
3015                        /* falls through */
3016                        case 'cross':
3017                            xOffset = Math.cos(rad) * radius;
3018                            yOffset = Math.sin(rad) * radius;
3019                            ctx.moveTo(x - xOffset, y - yOffset);
3020                            ctx.lineTo(x + xOffset, y + yOffset);
3021                            ctx.moveTo(x + yOffset, y - xOffset);
3022                            ctx.lineTo(x - yOffset, y + xOffset);
3023                            break;
3024                        case 'star':
3025                            xOffset = Math.cos(rad) * radius;
3026                            yOffset = Math.sin(rad) * radius;
3027                            ctx.moveTo(x - xOffset, y - yOffset);
3028                            ctx.lineTo(x + xOffset, y + yOffset);
3029                            ctx.moveTo(x + yOffset, y - xOffset);
3030                            ctx.lineTo(x - yOffset, y + xOffset);
3031                            rad += QUARTER_PI;
3032                            xOffset = Math.cos(rad) * radius;
3033                            yOffset = Math.sin(rad) * radius;
3034                            ctx.moveTo(x - xOffset, y - yOffset);
3035                            ctx.lineTo(x + xOffset, y + yOffset);
3036                            ctx.moveTo(x + yOffset, y - xOffset);
3037                            ctx.lineTo(x - yOffset, y + xOffset);
3038                            break;
3039                        case 'line':
3040                            xOffset = Math.cos(rad) * radius;
3041                            yOffset = Math.sin(rad) * radius;
3042                            ctx.moveTo(x - xOffset, y - yOffset);
3043                            ctx.lineTo(x + xOffset, y + yOffset);
3044                            break;
3045                        case 'dash':
3046                            ctx.moveTo(x, y);
3047                            ctx.lineTo(x + Math.cos(rad) * radius, y + Math.sin(rad) * radius);
3048                            break;
3049                    }
3050
3051                    ctx.fill();
3052                    ctx.stroke();
3053                },
3054
3055                /**
3056                 * Returns true if the point is inside the rectangle
3057                 * @param {object} point - The point to test
3058                 * @param {object} area - The rectangle
3059                 * @returns {boolean}
3060                 * @private
3061                 */
3062                _isPointInArea: function (point, area) {
3063                    var epsilon = 1e-6; // 1e-6 is margin in pixels for accumulated error.
3064
3065                    return point.x > area.left - epsilon && point.x < area.right + epsilon &&
3066                        point.y > area.top - epsilon && point.y < area.bottom + epsilon;
3067                },
3068
3069                clipArea: function (ctx, area) {
3070                    ctx.save();
3071                    ctx.beginPath();
3072                    ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);
3073                    ctx.clip();
3074                },
3075
3076                unclipArea: function (ctx) {
3077                    ctx.restore();
3078                },
3079
3080                lineTo: function (ctx, previous, target, flip) {
3081                    var stepped = target.steppedLine;
3082                    if (stepped) {
3083                        if (stepped === 'middle') {
3084                            var midpoint = (previous.x + target.x) / 2.0;
3085                            ctx.lineTo(midpoint, flip ? target.y : previous.y);
3086                            ctx.lineTo(midpoint, flip ? previous.y : target.y);
3087                        } else if ((stepped === 'after' && !flip) || (stepped !== 'after' && flip)) {
3088                            ctx.lineTo(previous.x, target.y);
3089                        } else {
3090                            ctx.lineTo(target.x, previous.y);
3091                        }
3092                        ctx.lineTo(target.x, target.y);
3093                        return;
3094                    }
3095
3096                    if (!target.tension) {
3097                        ctx.lineTo(target.x, target.y);
3098                        return;
3099                    }
3100
3101                    ctx.bezierCurveTo(
3102                        flip ? previous.controlPointPreviousX : previous.controlPointNextX,
3103                        flip ? previous.controlPointPreviousY : previous.controlPointNextY,
3104                        flip ? target.controlPointNextX : target.controlPointPreviousX,
3105                        flip ? target.controlPointNextY : target.controlPointPreviousY,
3106                        target.x,
3107                        target.y);
3108                }
3109            };
3110
3111            var helpers_canvas = exports$1;
3112
3113// DEPRECATIONS
3114
3115            /**
3116             * Provided for backward compatibility, use Chart.helpers.canvas.clear instead.
3117             * @namespace Chart.helpers.clear
3118             * @deprecated since version 2.7.0
3119             * @todo remove at version 3
3120             * @private
3121             */
3122            helpers_core.clear = exports$1.clear;
3123
3124            /**
3125             * Provided for backward compatibility, use Chart.helpers.canvas.roundedRect instead.
3126             * @namespace Chart.helpers.drawRoundedRectangle
3127             * @deprecated since version 2.7.0
3128             * @todo remove at version 3
3129             * @private
3130             */
3131            helpers_core.drawRoundedRectangle = function (ctx) {
3132                ctx.beginPath();
3133                exports$1.roundedRect.apply(exports$1, arguments);
3134            };
3135
3136            var defaults = {
3137                /**
3138                 * @private
3139                 */
3140                _set: function (scope, values) {
3141                    return helpers_core.merge(this[scope] || (this[scope] = {}), values);
3142                }
3143            };
3144
3145// TODO(v3): remove 'global' from namespace.  all default are global and
3146// there's inconsistency around which options are under 'global'
3147            defaults._set('global', {
3148                defaultColor: 'rgba(0,0,0,0.1)',
3149                defaultFontColor: '#666',
3150                defaultFontFamily: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
3151                defaultFontSize: 12,
3152                defaultFontStyle: 'normal',
3153                defaultLineHeight: 1.2,
3154                showLines: true
3155            });
3156
3157            var core_defaults = defaults;
3158
3159            var valueOrDefault = helpers_core.valueOrDefault;
3160
3161            /**
3162             * Converts the given font object into a CSS font string.
3163             * @param {object} font - A font object.
3164             * @return {string} The CSS font string. See https://developer.mozilla.org/en-US/docs/Web/CSS/font
3165             * @private
3166             */
3167            function toFontString(font) {
3168                if (!font || helpers_core.isNullOrUndef(font.size) || helpers_core.isNullOrUndef(font.family)) {
3169                    return null;
3170                }
3171
3172                return (font.style ? font.style + ' ' : '')
3173                    + (font.weight ? font.weight + ' ' : '')
3174                    + font.size + 'px '
3175                    + font.family;
3176            }
3177
3178            /**
3179             * @alias Chart.helpers.options
3180             * @namespace
3181             */
3182            var helpers_options = {
3183                /**
3184                 * Converts the given line height `value` in pixels for a specific font `size`.
3185                 * @param {number|string} value - The lineHeight to parse (eg. 1.6, '14px', '75%', '1.6em').
3186                 * @param {number} size - The font size (in pixels) used to resolve relative `value`.
3187                 * @returns {number} The effective line height in pixels (size * 1.2 if value is invalid).
3188                 * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-height
3189                 * @since 2.7.0
3190                 */
3191                toLineHeight: function (value, size) {
3192                    var matches = ('' + value).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);
3193                    if (!matches || matches[1] === 'normal') {
3194                        return size * 1.2;
3195                    }
3196
3197                    value = +matches[2];
3198
3199                    switch (matches[3]) {
3200                        case 'px':
3201                            return value;
3202                        case '%':
3203                            value /= 100;
3204                            break;
3205                    }
3206
3207                    return size * value;
3208                },
3209
3210                /**
3211                 * Converts the given value into a padding object with pre-computed width/height.
3212                 * @param {number|object} value - If a number, set the value to all TRBL component,
3213                 *  else, if and object, use defined properties and sets undefined ones to 0.
3214                 * @returns {object} The padding values (top, right, bottom, left, width, height)
3215                 * @since 2.7.0
3216                 */
3217                toPadding: function (value) {
3218                    var t, r, b, l;
3219
3220                    if (helpers_core.isObject(value)) {
3221                        t = +value.top || 0;
3222                        r = +value.right || 0;
3223                        b = +value.bottom || 0;
3224                        l = +value.left || 0;
3225                    } else {
3226                        t = r = b = l = +value || 0;
3227                    }
3228
3229                    return {
3230                        top: t,
3231                        right: r,
3232                        bottom: b,
3233                        left: l,
3234                        height: t + b,
3235                        width: l + r
3236                    };
3237                },
3238
3239                /**
3240                 * Parses font options and returns the font object.
3241                 * @param {object} options - A object that contains font options to be parsed.
3242                 * @return {object} The font object.
3243                 * @todo Support font.* options and renamed to toFont().
3244                 * @private
3245                 */
3246                _parseFont: function (options) {
3247                    var globalDefaults = core_defaults.global;
3248                    var size = valueOrDefault(options.fontSize, globalDefaults.defaultFontSize);
3249                    var font = {
3250                        family: valueOrDefault(options.fontFamily, globalDefaults.defaultFontFamily),
3251                        lineHeight: helpers_core.options.toLineHeight(valueOrDefault(options.lineHeight, globalDefaults.defaultLineHeight), size),
3252                        size: size,
3253                        style: valueOrDefault(options.fontStyle, globalDefaults.defaultFontStyle),
3254                        weight: null,
3255                        string: ''
3256                    };
3257
3258                    font.string = toFontString(font);
3259                    return font;
3260                },
3261
3262                /**
3263                 * Evaluates the given `inputs` sequentially and returns the first defined value.
3264                 * @param {Array} inputs - An array of values, falling back to the last value.
3265                 * @param {object} [context] - If defined and the current value is a function, the value
3266                 * is called with `context` as first argument and the result becomes the new input.
3267                 * @param {number} [index] - If defined and the current value is an array, the value
3268                 * at `index` become the new input.
3269                 * @param {object} [info] - object to return information about resolution in
3270                 * @param {boolean} [info.cacheable] - Will be set to `false` if option is not cacheable.
3271                 * @since 2.7.0
3272                 */
3273                resolve: function (inputs, context, index, info) {
3274                    var cacheable = true;
3275                    var i, ilen, value;
3276
3277                    for (i = 0, ilen = inputs.length; i < ilen; ++i) {
3278                        value = inputs[i];
3279                        if (value === undefined) {
3280                            continue;
3281                        }
3282                        if (context !== undefined && typeof value === 'function') {
3283                            value = value(context);
3284                            cacheable = false;
3285                        }
3286                        if (index !== undefined && helpers_core.isArray(value)) {
3287                            value = value[index];
3288                            cacheable = false;
3289                        }
3290                        if (value !== undefined) {
3291                            if (info && !cacheable) {
3292                                info.cacheable = false;
3293                            }
3294                            return value;
3295                        }
3296                    }
3297                }
3298            };
3299
3300            /**
3301             * @alias Chart.helpers.math
3302             * @namespace
3303             */
3304            var exports$2 = {
3305                /**
3306                 * Returns an array of factors sorted from 1 to sqrt(value)
3307                 * @private
3308                 */
3309                _factorize: function (value) {
3310                    var result = [];
3311                    var sqrt = Math.sqrt(value);
3312                    var i;
3313
3314                    for (i = 1; i < sqrt; i++) {
3315                        if (value % i === 0) {
3316                            result.push(i);
3317                            result.push(value / i);
3318                        }
3319                    }
3320                    if (sqrt === (sqrt | 0)) { // if value is a square number
3321                        result.push(sqrt);
3322                    }
3323
3324                    result.sort(function (a, b) {
3325                        return a - b;
3326                    }).pop();
3327                    return result;
3328                },
3329
3330                log10: Math.log10 || function (x) {
3331                    var exponent = Math.log(x) * Math.LOG10E; // Math.LOG10E = 1 / Math.LN10.
3332                    // Check for whole powers of 10,
3333                    // which due to floating point rounding error should be corrected.
3334                    var powerOf10 = Math.round(exponent);
3335                    var isPowerOf10 = x === Math.pow(10, powerOf10);
3336
3337                    return isPowerOf10 ? powerOf10 : exponent;
3338                }
3339            };
3340
3341            var helpers_math = exports$2;
3342
3343// DEPRECATIONS
3344
3345            /**
3346             * Provided for backward compatibility, use Chart.helpers.math.log10 instead.
3347             * @namespace Chart.helpers.log10
3348             * @deprecated since version 2.9.0
3349             * @todo remove at version 3
3350             * @private
3351             */
3352            helpers_core.log10 = exports$2.log10;
3353
3354            var getRtlAdapter = function (rectX, width) {
3355                return {
3356                    x: function (x) {
3357                        return rectX + rectX + width - x;
3358                    },
3359                    setWidth: function (w) {
3360                        width = w;
3361                    },
3362                    textAlign: function (align) {
3363                        if (align === 'center') {
3364                            return align;
3365                        }
3366                        return align === 'right' ? 'left' : 'right';
3367                    },
3368                    xPlus: function (x, value) {
3369                        return x - value;
3370                    },
3371                    leftForLtr: function (x, itemWidth) {
3372                        return x - itemWidth;
3373                    },
3374                };
3375            };
3376
3377            var getLtrAdapter = function () {
3378                return {
3379                    x: function (x) {
3380                        return x;
3381                    },
3382                    setWidth: function (w) { // eslint-disable-line no-unused-vars
3383                    },
3384                    textAlign: function (align) {
3385                        return align;
3386                    },
3387                    xPlus: function (x, value) {
3388                        return x + value;
3389                    },
3390                    leftForLtr: function (x, _itemWidth) { // eslint-disable-line no-unused-vars
3391                        return x;
3392                    },
3393                };
3394            };
3395
3396            var getAdapter = function (rtl, rectX, width) {
3397                return rtl ? getRtlAdapter(rectX, width) : getLtrAdapter();
3398            };
3399
3400            var overrideTextDirection = function (ctx, direction) {
3401                var style, original;
3402                if (direction === 'ltr' || direction === 'rtl') {
3403                    style = ctx.canvas.style;
3404                    original = [
3405                        style.getPropertyValue('direction'),
3406                        style.getPropertyPriority('direction'),
3407                    ];
3408
3409                    style.setProperty('direction', direction, 'important');
3410                    ctx.prevTextDirection = original;
3411                }
3412            };
3413
3414            var restoreTextDirection = function (ctx) {
3415                var original = ctx.prevTextDirection;
3416                if (original !== undefined) {
3417                    delete ctx.prevTextDirection;
3418                    ctx.canvas.style.setProperty('direction', original[0], original[1]);
3419                }
3420            };
3421
3422            var helpers_rtl = {
3423                getRtlAdapter: getAdapter,
3424                overrideTextDirection: overrideTextDirection,
3425                restoreTextDirection: restoreTextDirection,
3426            };
3427
3428            var helpers$1 = helpers_core;
3429            var easing = helpers_easing;
3430            var canvas = helpers_canvas;
3431            var options = helpers_options;
3432            var math = helpers_math;
3433            var rtl = helpers_rtl;
3434            helpers$1.easing = easing;
3435            helpers$1.canvas = canvas;
3436            helpers$1.options = options;
3437            helpers$1.math = math;
3438            helpers$1.rtl = rtl;
3439
3440            function interpolate(start, view, model, ease) {
3441                var keys = Object.keys(model);
3442                var i, ilen, key, actual, origin, target, type, c0, c1;
3443
3444                for (i = 0, ilen = keys.length; i < ilen; ++i) {
3445                    key = keys[i];
3446
3447                    target = model[key];
3448
3449                    // if a value is added to the model after pivot() has been called, the view
3450                    // doesn't contain it, so let's initialize the view to the target value.
3451                    if (!view.hasOwnProperty(key)) {
3452                        view[key] = target;
3453                    }
3454
3455                    actual = view[key];
3456
3457                    if (actual === target || key[0] === '_') {
3458                        continue;
3459                    }
3460
3461                    if (!start.hasOwnProperty(key)) {
3462                        start[key] = actual;
3463                    }
3464
3465                    origin = start[key];
3466
3467                    type = typeof target;
3468
3469                    if (type === typeof origin) {
3470                        if (type === 'string') {
3471                            c0 = chartjsColor(origin);
3472                            if (c0.valid) {
3473                                c1 = chartjsColor(target);
3474                                if (c1.valid) {
3475                                    view[key] = c1.mix(c0, ease).rgbString();
3476                                    continue;
3477                                }
3478                            }
3479                        } else if (helpers$1.isFinite(origin) && helpers$1.isFinite(target)) {
3480                            view[key] = origin + (target - origin) * ease;
3481                            continue;
3482                        }
3483                    }
3484
3485                    view[key] = target;
3486                }
3487            }
3488
3489            var Element = function (configuration) {
3490                helpers$1.extend(this, configuration);
3491                this.initialize.apply(this, arguments);
3492            };
3493
3494            helpers$1.extend(Element.prototype, {
3495                _type: undefined,
3496
3497                initialize: function () {
3498                    this.hidden = false;
3499                },
3500
3501                pivot: function () {
3502                    var me = this;
3503                    if (!me._view) {
3504                        me._view = helpers$1.extend({}, me._model);
3505                    }
3506                    me._start = {};
3507                    return me;
3508                },
3509
3510                transition: function (ease) {
3511                    var me = this;
3512                    var model = me._model;
3513                    var start = me._start;
3514                    var view = me._view;
3515
3516                    // No animation -> No Transition
3517                    if (!model || ease === 1) {
3518                        me._view = helpers$1.extend({}, model);
3519                        me._start = null;
3520                        return me;
3521                    }
3522
3523                    if (!view) {
3524                        view = me._view = {};
3525                    }
3526
3527                    if (!start) {
3528                        start = me._start = {};
3529                    }
3530
3531                    interpolate(start, view, model, ease);
3532
3533                    return me;
3534                },
3535
3536                tooltipPosition: function () {
3537                    return {
3538                        x: this._model.x,
3539                        y: this._model.y
3540                    };
3541                },
3542
3543                hasValue: function () {
3544                    return helpers$1.isNumber(this._model.x) && helpers$1.isNumber(this._model.y);
3545                }
3546            });
3547
3548            Element.extend = helpers$1.inherits;
3549
3550            var core_element = Element;
3551
3552            var exports$3 = core_element.extend({
3553                chart: null, // the animation associated chart instance
3554                currentStep: 0, // the current animation step
3555                numSteps: 60, // default number of steps
3556                easing: '', // the easing to use for this animation
3557                render: null, // render function used by the animation service
3558
3559                onAnimationProgress: null, // user specified callback to fire on each step of the animation
3560                onAnimationComplete: null, // user specified callback to fire when the animation finishes
3561            });
3562
3563            var core_animation = exports$3;
3564
3565// DEPRECATIONS
3566
3567            /**
3568             * Provided for backward compatibility, use Chart.Animation instead
3569             * @prop Chart.Animation#animationObject
3570             * @deprecated since version 2.6.0
3571             * @todo remove at version 3
3572             */
3573            Object.defineProperty(exports$3.prototype, 'animationObject', {
3574                get: function () {
3575                    return this;
3576                }
3577            });
3578
3579            /**
3580             * Provided for backward compatibility, use Chart.Animation#chart instead
3581             * @prop Chart.Animation#chartInstance
3582             * @deprecated since version 2.6.0
3583             * @todo remove at version 3
3584             */
3585            Object.defineProperty(exports$3.prototype, 'chartInstance', {
3586                get: function () {
3587                    return this.chart;
3588                },
3589                set: function (value) {
3590                    this.chart = value;
3591                }
3592            });
3593
3594            core_defaults._set('global', {
3595                animation: {
3596                    duration: 1000,
3597                    easing: 'easeOutQuart',
3598                    onProgress: helpers$1.noop,
3599                    onComplete: helpers$1.noop
3600                }
3601            });
3602
3603            var core_animations = {
3604                animations: [],
3605                request: null,
3606
3607                /**
3608                 * @param {Chart} chart - The chart to animate.
3609                 * @param {Chart.Animation} animation - The animation that we will animate.
3610                 * @param {number} duration - The animation duration in ms.
3611                 * @param {boolean} lazy - if true, the chart is not marked as animating to enable more responsive interactions
3612                 */
3613                addAnimation: function (chart, animation, duration, lazy) {
3614                    var animations = this.animations;
3615                    var i, ilen;
3616
3617                    animation.chart = chart;
3618                    animation.startTime = Date.now();
3619                    animation.duration = duration;
3620
3621                    if (!lazy) {
3622                        chart.animating = true;
3623                    }
3624
3625                    for (i = 0, ilen = animations.length; i < ilen; ++i) {
3626                        if (animations[i].chart === chart) {
3627                            animations[i] = animation;
3628                            return;
3629                        }
3630                    }
3631
3632                    animations.push(animation);
3633
3634                    // If there are no animations queued, manually kickstart a digest, for lack of a better word
3635                    if (animations.length === 1) {
3636                        this.requestAnimationFrame();
3637                    }
3638                },
3639
3640                cancelAnimation: function (chart) {
3641                    var index = helpers$1.findIndex(this.animations, function (animation) {
3642                        return animation.chart === chart;
3643                    });
3644
3645                    if (index !== -1) {
3646                        this.animations.splice(index, 1);
3647                        chart.animating = false;
3648                    }
3649                },
3650
3651                requestAnimationFrame: function () {
3652                    var me = this;
3653                    if (me.request === null) {
3654                        // Skip animation frame requests until the active one is executed.
3655                        // This can happen when processing mouse events, e.g. 'mousemove'
3656                        // and 'mouseout' events will trigger multiple renders.
3657                        me.request = helpers$1.requestAnimFrame.call(window, function () {
3658                            me.request = null;
3659                            me.startDigest();
3660                        });
3661                    }
3662                },
3663
3664                /**
3665                 * @private
3666                 */
3667                startDigest: function () {
3668                    var me = this;
3669
3670                    me.advance();
3671
3672                    // Do we have more stuff to animate?
3673                    if (me.animations.length > 0) {
3674                        me.requestAnimationFrame();
3675                    }
3676                },
3677
3678                /**
3679                 * @private
3680                 */
3681                advance: function () {
3682                    var animations = this.animations;
3683                    var animation, chart, numSteps, nextStep;
3684                    var i = 0;
3685
3686                    // 1 animation per chart, so we are looping charts here
3687                    while (i < animations.length) {
3688                        animation = animations[i];
3689                        chart = animation.chart;
3690                        numSteps = animation.numSteps;
3691
3692                        // Make sure that currentStep starts at 1
3693                        // https://github.com/chartjs/Chart.js/issues/6104
3694                        nextStep = Math.floor((Date.now() - animation.startTime) / animation.duration * numSteps) + 1;
3695                        animation.currentStep = Math.min(nextStep, numSteps);
3696
3697                        helpers$1.callback(animation.render, [chart, animation], chart);
3698                        helpers$1.callback(animation.onAnimationProgress, [animation], chart);
3699
3700                        if (animation.currentStep >= numSteps) {
3701                            helpers$1.callback(animation.onAnimationComplete, [animation], chart);
3702                            chart.animating = false;
3703                            animations.splice(i, 1);
3704                        } else {
3705                            ++i;
3706                        }
3707                    }
3708                }
3709            };
3710
3711            var resolve = helpers$1.options.resolve;
3712
3713            var arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift'];
3714
3715            /**
3716             * Hooks the array methods that add or remove values ('push', pop', 'shift', 'splice',
3717             * 'unshift') and notify the listener AFTER the array has been altered. Listeners are
3718             * called on the 'onData*' callbacks (e.g. onDataPush, etc.) with same arguments.
3719             */
3720            function listenArrayEvents(array, listener) {
3721                if (array._chartjs) {
3722                    array._chartjs.listeners.push(listener);
3723                    return;
3724                }
3725
3726                Object.defineProperty(array, '_chartjs', {
3727                    configurable: true,
3728                    enumerable: false,
3729                    value: {
3730                        listeners: [listener]
3731                    }
3732                });
3733
3734                arrayEvents.forEach(function (key) {
3735                    var method = 'onData' + key.charAt(0).toUpperCase() + key.slice(1);
3736                    var base = array[key];
3737
3738                    Object.defineProperty(array, key, {
3739                        configurable: true,
3740                        enumerable: false,
3741                        value: function () {
3742                            var args = Array.prototype.slice.call(arguments);
3743                            var res = base.apply(this, args);
3744
3745                            helpers$1.each(array._chartjs.listeners, function (object) {
3746                                if (typeof object[method] === 'function') {
3747                                    object[method].apply(object, args);
3748                                }
3749                            });
3750
3751                            return res;
3752                        }
3753                    });
3754                });
3755            }
3756
3757            /**
3758             * Removes the given array event listener and cleanup extra attached properties (such as
3759             * the _chartjs stub and overridden methods) if array doesn't have any more listeners.
3760             */
3761            function unlistenArrayEvents(array, listener) {
3762                var stub = array._chartjs;
3763                if (!stub) {
3764                    return;
3765                }
3766
3767                var listeners = stub.listeners;
3768                var index = listeners.indexOf(listener);
3769                if (index !== -1) {
3770                    listeners.splice(index, 1);
3771                }
3772
3773                if (listeners.length > 0) {
3774                    return;
3775                }
3776