https://vniispk.ru/ui/v3/chart.js

1/*!
2 * Chart.js v3.4.1
3 * https://www.chartjs.org
4 * (c) 2021 Chart.js Contributors
5 * Released under the MIT License
6 *
7 * chartjs-adapter-date-fns v2.0.0
8 * https://www.chartjs.org
9 * (c) 2021 chartjs-adapter-date-fns Contributors
10 * Released under the MIT license
11 *
12 * date-fns v2.21.1
13 * https://date-fns.org
14 * (c) 2020 Sasha Koss and Lesha Koss
15 * Released under the MIT License
16 */
17
18(function (global, factory) {
19  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
20  typeof define === 'function' && define.amd ? define(factory) :
21  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Chart = factory());
22}(this, (function () { 'use strict';
23
24  function _typeof(obj) {
25    "@babel/helpers - typeof";
26
27    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
28      _typeof = function (obj) {
29        return typeof obj;
30      };
31    } else {
32      _typeof = function (obj) {
33        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
34      };
35    }
36
37    return _typeof(obj);
38  }
39
40  function _classCallCheck(instance, Constructor) {
41    if (!(instance instanceof Constructor)) {
42      throw new TypeError("Cannot call a class as a function");
43    }
44  }
45
46  function _defineProperties(target, props) {
47    for (var i = 0; i < props.length; i++) {
48      var descriptor = props[i];
49      descriptor.enumerable = descriptor.enumerable || false;
50      descriptor.configurable = true;
51      if ("value" in descriptor) descriptor.writable = true;
52      Object.defineProperty(target, descriptor.key, descriptor);
53    }
54  }
55
56  function _createClass(Constructor, protoProps, staticProps) {
57    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
58    if (staticProps) _defineProperties(Constructor, staticProps);
59    return Constructor;
60  }
61
62  function _defineProperty(obj, key, value) {
63    if (key in obj) {
64      Object.defineProperty(obj, key, {
65        value: value,
66        enumerable: true,
67        configurable: true,
68        writable: true
69      });
70    } else {
71      obj[key] = value;
72    }
73
74    return obj;
75  }
76
77  function ownKeys(object, enumerableOnly) {
78    var keys = Object.keys(object);
79
80    if (Object.getOwnPropertySymbols) {
81      var symbols = Object.getOwnPropertySymbols(object);
82      if (enumerableOnly) symbols = symbols.filter(function (sym) {
83        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
84      });
85      keys.push.apply(keys, symbols);
86    }
87
88    return keys;
89  }
90
91  function _objectSpread2(target) {
92    for (var i = 1; i < arguments.length; i++) {
93      var source = arguments[i] != null ? arguments[i] : {};
94
95      if (i % 2) {
96        ownKeys(Object(source), true).forEach(function (key) {
97          _defineProperty(target, key, source[key]);
98        });
99      } else if (Object.getOwnPropertyDescriptors) {
100        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
101      } else {
102        ownKeys(Object(source)).forEach(function (key) {
103          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
104        });
105      }
106    }
107
108    return target;
109  }
110
111  function _inherits(subClass, superClass) {
112    if (typeof superClass !== "function" && superClass !== null) {
113      throw new TypeError("Super expression must either be null or a function");
114    }
115
116    subClass.prototype = Object.create(superClass && superClass.prototype, {
117      constructor: {
118        value: subClass,
119        writable: true,
120        configurable: true
121      }
122    });
123    if (superClass) _setPrototypeOf(subClass, superClass);
124  }
125
126  function _getPrototypeOf(o) {
127    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
128      return o.__proto__ || Object.getPrototypeOf(o);
129    };
130    return _getPrototypeOf(o);
131  }
132
133  function _setPrototypeOf(o, p) {
134    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
135      o.__proto__ = p;
136      return o;
137    };
138
139    return _setPrototypeOf(o, p);
140  }
141
142  function _isNativeReflectConstruct() {
143    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
144    if (Reflect.construct.sham) return false;
145    if (typeof Proxy === "function") return true;
146
147    try {
148      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
149      return true;
150    } catch (e) {
151      return false;
152    }
153  }
154
155  function _assertThisInitialized(self) {
156    if (self === void 0) {
157      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
158    }
159
160    return self;
161  }
162
163  function _possibleConstructorReturn(self, call) {
164    if (call && (typeof call === "object" || typeof call === "function")) {
165      return call;
166    }
167
168    return _assertThisInitialized(self);
169  }
170
171  function _createSuper(Derived) {
172    var hasNativeReflectConstruct = _isNativeReflectConstruct();
173
174    return function _createSuperInternal() {
175      var Super = _getPrototypeOf(Derived),
176          result;
177
178      if (hasNativeReflectConstruct) {
179        var NewTarget = _getPrototypeOf(this).constructor;
180
181        result = Reflect.construct(Super, arguments, NewTarget);
182      } else {
183        result = Super.apply(this, arguments);
184      }
185
186      return _possibleConstructorReturn(this, result);
187    };
188  }
189
190  function _superPropBase(object, property) {
191    while (!Object.prototype.hasOwnProperty.call(object, property)) {
192      object = _getPrototypeOf(object);
193      if (object === null) break;
194    }
195
196    return object;
197  }
198
199  function _get(target, property, receiver) {
200    if (typeof Reflect !== "undefined" && Reflect.get) {
201      _get = Reflect.get;
202    } else {
203      _get = function _get(target, property, receiver) {
204        var base = _superPropBase(target, property);
205
206        if (!base) return;
207        var desc = Object.getOwnPropertyDescriptor(base, property);
208
209        if (desc.get) {
210          return desc.get.call(receiver);
211        }
212
213        return desc.value;
214      };
215    }
216
217    return _get(target, property, receiver || target);
218  }
219
220  function _slicedToArray(arr, i) {
221    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
222  }
223
224  function _toConsumableArray(arr) {
225    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
226  }
227
228  function _arrayWithoutHoles(arr) {
229    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
230  }
231
232  function _arrayWithHoles(arr) {
233    if (Array.isArray(arr)) return arr;
234  }
235
236  function _iterableToArray(iter) {
237    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
238  }
239
240  function _iterableToArrayLimit(arr, i) {
241    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
242    var _arr = [];
243    var _n = true;
244    var _d = false;
245    var _e = undefined;
246
247    try {
248      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
249        _arr.push(_s.value);
250
251        if (i && _arr.length === i) break;
252      }
253    } catch (err) {
254      _d = true;
255      _e = err;
256    } finally {
257      try {
258        if (!_n && _i["return"] != null) _i["return"]();
259      } finally {
260        if (_d) throw _e;
261      }
262    }
263
264    return _arr;
265  }
266
267  function _unsupportedIterableToArray(o, minLen) {
268    if (!o) return;
269    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
270    var n = Object.prototype.toString.call(o).slice(8, -1);
271    if (n === "Object" && o.constructor) n = o.constructor.name;
272    if (n === "Map" || n === "Set") return Array.from(o);
273    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
274  }
275
276  function _arrayLikeToArray(arr, len) {
277    if (len == null || len > arr.length) len = arr.length;
278
279    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
280
281    return arr2;
282  }
283
284  function _nonIterableSpread() {
285    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
286  }
287
288  function _nonIterableRest() {

289    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
290  }
291
292  function _createForOfIteratorHelper(o, allowArrayLike) {
293    var it;
294
295    if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
296      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
297        if (it) o = it;
298        var i = 0;
299
300        var F = function () {};
301
302        return {
303          s: F,
304          n: function () {
305            if (i >= o.length) return {
306              done: true
307            };
308            return {
309              done: false,
310              value: o[i++]
311            };
312          },
313          e: function (e) {
314            throw e;
315          },
316          f: F
317        };
318      }
319
320      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
321    }
322
323    var normalCompletion = true,
324        didErr = false,
325        err;
326    return {
327      s: function () {
328        it = o[Symbol.iterator]();
329      },
330      n: function () {
331        var step = it.next();
332        normalCompletion = step.done;
333        return step;
334      },
335      e: function (e) {
336        didErr = true;
337        err = e;
338      },
339      f: function () {
340        try {
341          if (!normalCompletion && it.return != null) it.return();
342        } finally {
343          if (didErr) throw err;
344        }
345      }
346    };
347  }
348
349  var requestAnimFrame = function () {
350    if (typeof window === 'undefined') {
351      return function (callback) {
352        return callback();
353      };
354    }
355
356    return window.requestAnimationFrame;
357  }();
358
359  function throttled(fn, thisArg, updateFn) {
360    var updateArgs = updateFn || function (args) {
361      return Array.prototype.slice.call(args);
362    };
363
364    var ticking = false;
365    var args = [];
366    return function () {
367      for (var _len = arguments.length, rest = new Array(_len), _key = 0; _key < _len; _key++) {
368        rest[_key] = arguments[_key];
369      }
370
371      args = updateArgs(rest);
372
373      if (!ticking) {
374        ticking = true;
375        requestAnimFrame.call(window, function () {
376          ticking = false;
377          fn.apply(thisArg, args);
378        });
379      }
380    };
381  }
382
383  function debounce(fn, delay) {
384    var timeout;
385    return function () {
386      if (delay) {
387        clearTimeout(timeout);
388        timeout = setTimeout(fn, delay);
389      } else {
390        fn();
391      }
392
393      return delay;
394    };
395  }
396
397  var _toLeftRightCenter = function _toLeftRightCenter(align) {
398    return align === 'start' ? 'left' : align === 'end' ? 'right' : 'center';
399  };
400
401  var _alignStartEnd = function _alignStartEnd(align, start, end) {
402    return align === 'start' ? start : align === 'end' ? end : (start + end) / 2;
403  };
404
405  var _textX = function _textX(align, left, right, rtl) {
406    var check = rtl ? 'left' : 'right';
407    return align === check ? right : align === 'center' ? (left + right) / 2 : left;
408  };
409
410  function noop() {}
411
412  var uid = function () {
413    var id = 0;
414    return function () {
415      return id++;
416    };
417  }();
418
419  function isNullOrUndef(value) {
420    return value === null || typeof value === 'undefined';
421  }
422
423  function isArray(value) {
424    if (Array.isArray && Array.isArray(value)) {
425      return true;
426    }
427
428    var type = Object.prototype.toString.call(value);
429
430    if (type.substr(0, 7) === '[object' && type.substr(-6) === 'Array]') {
431      return true;
432    }
433
434    return false;
435  }
436
437  function isObject(value) {
438    return value !== null && Object.prototype.toString.call(value) === '[object Object]';
439  }
440
441  var isNumberFinite = function isNumberFinite(value) {
442    return (typeof value === 'number' || value instanceof Number) && isFinite(+value);
443  };
444
445  function finiteOrDefault(value, defaultValue) {
446    return isNumberFinite(value) ? value : defaultValue;
447  }
448
449  function valueOrDefault(value, defaultValue) {
450    return typeof value === 'undefined' ? defaultValue : value;
451  }
452
453  var toPercentage = function toPercentage(value, dimension) {
454    return typeof value === 'string' && value.endsWith('%') ? parseFloat(value) / 100 : value / dimension;
455  };
456
457  var toDimension = function toDimension(value, dimension) {
458    return typeof value === 'string' && value.endsWith('%') ? parseFloat(value) / 100 * dimension : +value;
459  };
460
461  function callback(fn, args, thisArg) {
462    if (fn && typeof fn.call === 'function') {
463      return fn.apply(thisArg, args);
464    }
465  }
466
467  function each(loopable, fn, thisArg, reverse) {
468    var i, len, keys;
469
470    if (isArray(loopable)) {
471      len = loopable.length;
472
473      if (reverse) {
474        for (i = len - 1; i >= 0; i--) {
475          fn.call(thisArg, loopable[i], i);
476        }
477      } else {
478        for (i = 0; i < len; i++) {
479          fn.call(thisArg, loopable[i], i);
480        }
481      }
482    } else if (isObject(loopable)) {
483      keys = Object.keys(loopable);
484      len = keys.length;
485
486      for (i = 0; i < len; i++) {
487        fn.call(thisArg, loopable[keys[i]], keys[i]);
488      }
489    }
490  }
491
492  function _elementsEqual(a0, a1) {
493    var i, ilen, v0, v1;
494
495    if (!a0 || !a1 || a0.length !== a1.length) {
496      return false;

497    }
498
499    for (i = 0, ilen = a0.length; i < ilen; ++i) {
500      v0 = a0[i];
501      v1 = a1[i];
502
503      if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {
504        return false;
505      }
506    }
507
508    return true;
509  }
510
511  function clone$1(source) {
512    if (isArray(source)) {
513      return source.map(clone$1);
514    }
515
516    if (isObject(source)) {
517      var target = Object.create(null);
518      var keys = Object.keys(source);
519      var klen = keys.length;
520      var k = 0;
521
522      for (; k < klen; ++k) {
523        target[keys[k]] = clone$1(source[keys[k]]);
524      }
525
526      return target;
527    }
528
529    return source;
530  }
531
532  function isValidKey(key) {
533    return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1;
534  }
535
536  function _merger(key, target, source, options) {
537    if (!isValidKey(key)) {
538      return;
539    }
540
541    var tval = target[key];
542    var sval = source[key];
543
544    if (isObject(tval) && isObject(sval)) {
545      merge(tval, sval, options);
546    } else {
547      target[key] = clone$1(sval);
548    }
549  }
550
551  function merge(target, source, options) {
552    var sources = isArray(source) ? source : [source];
553    var ilen = sources.length;
554
555    if (!isObject(target)) {
556      return target;
557    }
558
559    options = options || {};
560    var merger = options.merger || _merger;
561
562    for (var i = 0; i < ilen; ++i) {
563      source = sources[i];
564
565      if (!isObject(source)) {
566        continue;
567      }
568
569      var keys = Object.keys(source);
570
571      for (var k = 0, klen = keys.length; k < klen; ++k) {
572        merger(keys[k], target, source, options);
573      }
574    }
575
576    return target;
577  }
578
579  function mergeIf(target, source) {
580    return merge(target, source, {
581      merger: _mergerIf
582    });
583  }
584
585  function _mergerIf(key, target, source) {
586    if (!isValidKey(key)) {
587      return;
588    }
589
590    var tval = target[key];
591    var sval = source[key];
592
593    if (isObject(tval) && isObject(sval)) {
594      mergeIf(tval, sval);
595    } else if (!Object.prototype.hasOwnProperty.call(target, key)) {
596      target[key] = clone$1(sval);
597    }
598  }
599
600  var emptyString = '';
601  var dot = '.';
602
603  function indexOfDotOrLength(key, start) {
604    var idx = key.indexOf(dot, start);
605    return idx === -1 ? key.length : idx;
606  }
607
608  function resolveObjectKey(obj, key) {
609    if (key === emptyString) {
610      return obj;
611    }
612
613    var pos = 0;
614    var idx = indexOfDotOrLength(key, pos);
615
616    while (obj && idx > pos) {
617      obj = obj[key.substr(pos, idx - pos)];
618      pos = idx + 1;
619      idx = indexOfDotOrLength(key, pos);
620    }
621
622    return obj;
623  }
624
625  function _capitalize(str) {
626    return str.charAt(0).toUpperCase() + str.slice(1);
627  }
628
629  var defined = function defined(value) {
630    return typeof value !== 'undefined';
631  };
632
633  var isFunction = function isFunction(value) {
634    return typeof value === 'function';
635  };
636
637  var setsEqual = function setsEqual(a, b) {
638    if (a.size !== b.size) {
639      return false;
640    }
641
642    var _iterator = _createForOfIteratorHelper(a),
643        _step;
644
645    try {
646      for (_iterator.s(); !(_step = _iterator.n()).done;) {
647        var item = _step.value;
648
649        if (!b.has(item)) {
650          return false;
651        }
652      }
653    } catch (err) {
654      _iterator.e(err);
655    } finally {
656      _iterator.f();
657    }
658
659    return true;
660  };
661
662  var PI = Math.PI;
663  var TAU = 2 * PI;
664  var PITAU = TAU + PI;
665  var INFINITY = Number.POSITIVE_INFINITY;
666  var RAD_PER_DEG = PI / 180;
667  var HALF_PI = PI / 2;
668  var QUARTER_PI = PI / 4;
669  var TWO_THIRDS_PI = PI * 2 / 3;
670  var log10 = Math.log10;
671  var sign = Math.sign;
672
673  function niceNum(range) {
674    var roundedRange = Math.round(range);
675    range = almostEquals(range, roundedRange, range / 1000) ? roundedRange : range;
676    var niceRange = Math.pow(10, Math.floor(log10(range)));
677    var fraction = range / niceRange;
678    var niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;
679    return niceFraction * niceRange;
680  }
681
682  function _factorize(value) {
683    var result = [];
684    var sqrt = Math.sqrt(value);
685    var i;
686
687    for (i = 1; i < sqrt; i++) {
688      if (value % i === 0) {
689        result.push(i);
690        result.push(value / i);
691      }
692    }
693
694    if (sqrt === (sqrt | 0)) {
695      result.push(sqrt);
696    }
697
698    result.sort(function (a, b) {
699      return a - b;
700    }).pop();
701    return result;
702  }
703
704  function isNumber(n) {
705    return !isNaN(parseFloat(n)) && isFinite(n);
706  }
707
708  function almostEquals(x, y, epsilon) {
709    return Math.abs(x - y) < epsilon;
710  }
711
712  function almostWhole(x, epsilon) {
713    var rounded = Math.round(x);
714    return rounded - epsilon <= x && rounded + epsilon >= x;
715  }
716
717  function _setMinAndMaxByKey(array, target, property) {
718    var i, ilen, value;
719
720    for (i = 0, ilen = array.length; i < ilen; i++) {
721      value = array[i][property];
722
723      if (!isNaN(value)) {
724        target.min = Math.min(target.min, value);
725        target.max = Math.max(target.max, value);
726      }
727    }
728  }
729
730  function toRadians(degrees) {
731    return degrees * (PI / 180);
732  }
733
734  function toDegrees(radians) {
735    return radians * (180 / PI);
736  }
737
738  function _decimalPlaces(x) {
739    if (!isNumberFinite(x)) {
740      return;
741    }
742
743    var e = 1;
744    var p = 0;
745
746    while (Math.round(x * e) / e !== x) {
747      e *= 10;
748      p++;
749    }
750
751    return p;
752  }
753
754  function getAngleFromPoint(centrePoint, anglePoint) {
755    var distanceFromXCenter = anglePoint.x - centrePoint.x;
756    var distanceFromYCenter = anglePoint.y - centrePoint.y;
757    var radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
758    var angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
759
760    if (angle < -0.5 * PI) {
761      angle += TAU;
762    }
763
764    return {
765      angle: angle,
766      distance: radialDistanceFromCenter
767    };
768  }
769
770  function distanceBetweenPoints(pt1, pt2) {
771    return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
772  }
773
774  function _angleDiff(a, b) {

775    return (a - b + PITAU) % TAU - PI;
776  }
777
778  function _normalizeAngle(a) {
779    return (a % TAU + TAU) % TAU;
780  }
781
782  function _angleBetween(angle, start, end, sameAngleIsFullCircle) {
783    var a = _normalizeAngle(angle);
784
785    var s = _normalizeAngle(start);
786
787    var e = _normalizeAngle(end);
788
789    var angleToStart = _normalizeAngle(s - a);
790
791    var angleToEnd = _normalizeAngle(e - a);
792
793    var startToAngle = _normalizeAngle(a - s);
794
795    var endToAngle = _normalizeAngle(a - e);
796
797    return a === s || a === e || sameAngleIsFullCircle && s === e || angleToStart > angleToEnd && startToAngle < endToAngle;
798  }
799
800  function _limitValue(value, min, max) {
801    return Math.max(min, Math.min(max, value));
802  }
803
804  function _int16Range(value) {
805    return _limitValue(value, -32768, 32767);
806  }
807
808  var atEdge = function atEdge(t) {
809    return t === 0 || t === 1;
810  };
811
812  var elasticIn = function elasticIn(t, s, p) {
813    return -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p));
814  };
815
816  var elasticOut = function elasticOut(t, s, p) {
817    return Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1;
818  };
819
820  var effects = {
821    linear: function linear(t) {
822      return t;
823    },
824    easeInQuad: function easeInQuad(t) {
825      return t * t;
826    },
827    easeOutQuad: function easeOutQuad(t) {
828      return -t * (t - 2);
829    },
830    easeInOutQuad: function easeInOutQuad(t) {
831      return (t /= 0.5) < 1 ? 0.5 * t * t : -0.5 * (--t * (t - 2) - 1);
832    },
833    easeInCubic: function easeInCubic(t) {
834      return t * t * t;
835    },
836    easeOutCubic: function easeOutCubic(t) {
837      return (t -= 1) * t * t + 1;
838    },
839    easeInOutCubic: function easeInOutCubic(t) {
840      return (t /= 0.5) < 1 ? 0.5 * t * t * t : 0.5 * ((t -= 2) * t * t + 2);
841    },
842    easeInQuart: function easeInQuart(t) {
843      return t * t * t * t;
844    },
845    easeOutQuart: function easeOutQuart(t) {
846      return -((t -= 1) * t * t * t - 1);
847    },
848    easeInOutQuart: function easeInOutQuart(t) {
849      return (t /= 0.5) < 1 ? 0.5 * t * t * t * t : -0.5 * ((t -= 2) * t * t * t - 2);
850    },
851    easeInQuint: function easeInQuint(t) {
852      return t * t * t * t * t;
853    },
854    easeOutQuint: function easeOutQuint(t) {
855      return (t -= 1) * t * t * t * t + 1;
856    },
857    easeInOutQuint: function easeInOutQuint(t) {
858      return (t /= 0.5) < 1 ? 0.5 * t * t * t * t * t : 0.5 * ((t -= 2) * t * t * t * t + 2);
859    },
860    easeInSine: function easeInSine(t) {
861      return -Math.cos(t * HALF_PI) + 1;
862    },
863    easeOutSine: function easeOutSine(t) {
864      return Math.sin(t * HALF_PI);
865    },
866    easeInOutSine: function easeInOutSine(t) {
867      return -0.5 * (Math.cos(PI * t) - 1);
868    },
869    easeInExpo: function easeInExpo(t) {
870      return t === 0 ? 0 : Math.pow(2, 10 * (t - 1));
871    },
872    easeOutExpo: function easeOutExpo(t) {
873      return t === 1 ? 1 : -Math.pow(2, -10 * t) + 1;
874    },
875    easeInOutExpo: function easeInOutExpo(t) {
876      return atEdge(t) ? t : t < 0.5 ? 0.5 * Math.pow(2, 10 * (t * 2 - 1)) : 0.5 * (-Math.pow(2, -10 * (t * 2 - 1)) + 2);
877    },
878    easeInCirc: function easeInCirc(t) {
879      return t >= 1 ? t : -(Math.sqrt(1 - t * t) - 1);
880    },
881    easeOutCirc: function easeOutCirc(t) {
882      return Math.sqrt(1 - (t -= 1) * t);
883    },
884    easeInOutCirc: function easeInOutCirc(t) {
885      return (t /= 0.5) < 1 ? -0.5 * (Math.sqrt(1 - t * t) - 1) : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1);
886    },
887    easeInElastic: function easeInElastic(t) {
888      return atEdge(t) ? t : elasticIn(t, 0.075, 0.3);
889    },
890    easeOutElastic: function easeOutElastic(t) {
891      return atEdge(t) ? t : elasticOut(t, 0.075, 0.3);
892    },
893    easeInOutElastic: function easeInOutElastic(t) {
894      var s = 0.1125;
895      var p = 0.45;
896      return atEdge(t) ? t : t < 0.5 ? 0.5 * elasticIn(t * 2, s, p) : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p);
897    },
898    easeInBack: function easeInBack(t) {
899      var s = 1.70158;
900      return t * t * ((s + 1) * t - s);
901    },
902    easeOutBack: function easeOutBack(t) {
903      var s = 1.70158;
904      return (t -= 1) * t * ((s + 1) * t + s) + 1;
905    },
906    easeInOutBack: function easeInOutBack(t) {
907      var s = 1.70158;
908
909      if ((t /= 0.5) < 1) {
910        return 0.5 * (t * t * (((s *= 1.525) + 1) * t - s));
911      }
912

913      return 0.5 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2);
914    },
915    easeInBounce: function easeInBounce(t) {
916      return 1 - effects.easeOutBounce(1 - t);
917    },
918    easeOutBounce: function easeOutBounce(t) {
919      var m = 7.5625;
920      var d = 2.75;
921
922      if (t < 1 / d) {
923        return m * t * t;
924      }
925
926      if (t < 2 / d) {
927        return m * (t -= 1.5 / d) * t + 0.75;
928      }
929
930      if (t < 2.5 / d) {
931        return m * (t -= 2.25 / d) * t + 0.9375;
932      }
933
934      return m * (t -= 2.625 / d) * t + 0.984375;
935    },
936    easeInOutBounce: function easeInOutBounce(t) {
937      return t < 0.5 ? effects.easeInBounce(t * 2) * 0.5 : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5;
938    }
939  };
940  /*!
941   * @kurkle/color v0.1.9
942   * https://github.com/kurkle/color#readme
943   * (c) 2020 Jukka Kurkela
944   * Released under the MIT License
945   */
946
947  var map$1 = {
948    0: 0,
949    1: 1,
950    2: 2,
951    3: 3,
952    4: 4,
953    5: 5,
954    6: 6,
955    7: 7,
956    8: 8,
957    9: 9,
958    A: 10,
959    B: 11,
960    C: 12,
961    D: 13,
962    E: 14,
963    F: 15,
964    a: 10,
965    b: 11,
966    c: 12,
967    d: 13,
968    e: 14,
969    f: 15
970  };
971  var hex = '0123456789ABCDEF';
972
973  var h1 = function h1(b) {
974    return hex[b & 0xF];
975  };
976
977  var h2 = function h2(b) {
978    return hex[(b & 0xF0) >> 4] + hex[b & 0xF];
979  };
980
981  var eq = function eq(b) {
982    return (b & 0xF0) >> 4 === (b & 0xF);
983  };
984
985  function isShort(v) {
986    return eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a);
987  }
988
989  function hexParse(str) {
990    var len = str.length;
991    var ret;
992
993    if (str[0] === '#') {
994      if (len === 4 || len === 5) {
995        ret = {
996          r: 255 & map$1[str[1]] * 17,
997          g: 255 & map$1[str[2]] * 17,
998          b: 255 & map$1[str[3]] * 17,
999          a: len === 5 ? map$1[str[4]] * 17 : 255
1000        };
1001      } else if (len === 7 || len === 9) {
1002        ret = {
1003          r: map$1[str[1]] << 4 | map$1[str[2]],
1004          g: map$1[str[3]] << 4 | map$1[str[4]],
1005          b: map$1[str[5]] << 4 | map$1[str[6]],
1006          a: len === 9 ? map$1[str[7]] << 4 | map$1[str[8]] : 255
1007        };
1008      }
1009    }
1010
1011    return ret;
1012  }
1013
1014  function _hexString(v) {
1015    var f = isShort(v) ? h1 : h2;
1016    return v ? '#' + f(v.r) + f(v.g) + f(v.b) + (v.a < 255 ? f(v.a) : '') : v;
1017  }
1018
1019  function round(v) {
1020    return v + 0.5 | 0;
1021  }
1022
1023  var lim = function lim(v, l, h) {
1024    return Math.max(Math.min(v, h), l);
1025  };
1026
1027  function p2b(v) {
1028    return lim(round(v * 2.55), 0, 255);
1029  }
1030
1031  function n2b(v) {
1032    return lim(round(v * 255), 0, 255);
1033  }
1034
1035  function b2n(v) {
1036    return lim(round(v / 2.55) / 100, 0, 1);
1037  }
1038
1039  function n2p(v) {
1040    return lim(round(v * 100), 0, 100);
1041  }
1042
1043  var RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;
1044
1045  function rgbParse(str) {
1046    var m = RGB_RE.exec(str);
1047    var a = 255;
1048    var r, g, b;
1049
1050    if (!m) {
1051      return;
1052    }
1053
1054    if (m[7] !== r) {
1055      var v = +m[7];
1056      a = 255 & (m[8] ? p2b(v) : v * 255);
1057    }
1058
1059    r = +m[1];
1060    g = +m[3];
1061    b = +m[5];
1062    r = 255 & (m[2] ? p2b(r) : r);
1063    g = 255 & (m[4] ? p2b(g) : g);
1064    b = 255 & (m[6] ? p2b(b) : b);
1065    return {
1066      r: r,
1067      g: g,
1068      b: b,
1069      a: a
1070    };
1071  }
1072
1073  function _rgbString(v) {
1074    return v && (v.a < 255 ? "rgba(".concat(v.r, ", ").concat(v.g, ", ").concat(v.b, ", ").concat(b2n(v.a), ")") : "rgb(".concat(v.r, ", ").concat(v.g, ", ").concat(v.b, ")"));
1075  }
1076
1077  var HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;
1078
1079  function hsl2rgbn(h, s, l) {
1080    var a = s * Math.min(l, 1 - l);
1081
1082    var f = function f(n) {
1083      var k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 30) % 12;
1084      return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
1085    };
1086
1087    return [f(0), f(8), f(4)];
1088  }
1089
1090  function hsv2rgbn(h, s, v) {
1091    var f = function f(n) {
1092      var k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 60) % 6;
1093      return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
1094    };
1095
1096    return [f(5), f(3), f(1)];
1097  }
1098
1099  function hwb2rgbn(h, w, b) {
1100    var rgb = hsl2rgbn(h, 1, 0.5);
1101    var i;
1102
1103    if (w + b > 1) {
1104      i = 1 / (w + b);
1105      w *= i;
1106      b *= i;
1107    }
1108
1109    for (i = 0; i < 3; i++) {
1110      rgb[i] *= 1 - w - b;

1111      rgb[i] += w;
1112    }
1113
1114    return rgb;
1115  }
1116
1117  function rgb2hsl(v) {
1118    var range = 255;
1119    var r = v.r / range;
1120    var g = v.g / range;
1121    var b = v.b / range;
1122    var max = Math.max(r, g, b);
1123    var min = Math.min(r, g, b);
1124    var l = (max + min) / 2;
1125    var h, s, d;
1126
1127    if (max !== min) {
1128      d = max - min;
1129      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
1130      h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
1131      h = h * 60 + 0.5;
1132    }
1133
1134    return [h | 0, s || 0, l];
1135  }
1136
1137  function calln(f, a, b, c) {
1138    return (Array.isArray(a) ? f(a[0], a[1], a[2]) : f(a, b, c)).map(n2b);
1139  }
1140
1141  function hsl2rgb(h, s, l) {
1142    return calln(hsl2rgbn, h, s, l);
1143  }
1144
1145  function hwb2rgb(h, w, b) {
1146    return calln(hwb2rgbn, h, w, b);
1147  }
1148
1149  function hsv2rgb(h, s, v) {
1150    return calln(hsv2rgbn, h, s, v);
1151  }
1152
1153  function hue(h) {
1154    return (h % 360 + 360) % 360;
1155  }
1156
1157  function hueParse(str) {
1158    var m = HUE_RE.exec(str);
1159    var a = 255;
1160    var v;
1161
1162    if (!m) {
1163      return;
1164    }
1165
1166    if (m[5] !== v) {
1167      a = m[6] ? p2b(+m[5]) : n2b(+m[5]);
1168    }
1169
1170    var h = hue(+m[2]);
1171    var p1 = +m[3] / 100;
1172    var p2 = +m[4] / 100;
1173
1174    if (m[1] === 'hwb') {
1175      v = hwb2rgb(h, p1, p2);
1176    } else if (m[1] === 'hsv') {
1177      v = hsv2rgb(h, p1, p2);
1178    } else {
1179      v = hsl2rgb(h, p1, p2);
1180    }
1181
1182    return {
1183      r: v[0],
1184      g: v[1],
1185      b: v[2],
1186      a: a
1187    };
1188  }
1189
1190  function _rotate(v, deg) {
1191    var h = rgb2hsl(v);
1192    h[0] = hue(h[0] + deg);
1193    h = hsl2rgb(h);
1194    v.r = h[0];
1195    v.g = h[1];
1196    v.b = h[2];
1197  }
1198
1199  function _hslString(v) {
1200    if (!v) {
1201      return;
1202    }
1203
1204    var a = rgb2hsl(v);
1205    var h = a[0];
1206    var s = n2p(a[1]);
1207    var l = n2p(a[2]);
1208    return v.a < 255 ? "hsla(".concat(h, ", ").concat(s, "%, ").concat(l, "%, ").concat(b2n(v.a), ")") : "hsl(".concat(h, ", ").concat(s, "%, ").concat(l, "%)");
1209  }
1210
1211  var map$1$1 = {
1212    x: 'dark',
1213    Z: 'light',
1214    Y: 're',
1215    X: 'blu',
1216    W: 'gr',
1217    V: 'medium',
1218    U: 'slate',
1219    A: 'ee',
1220    T: 'ol',
1221    S: 'or',
1222    B: 'ra',
1223    C: 'lateg',
1224    D: 'ights',
1225    R: 'in',
1226    Q: 'turquois',
1227    E: 'hi',
1228    P: 'ro',
1229    O: 'al',
1230    N: 'le',
1231    M: 'de',
1232    L: 'yello',
1233    F: 'en',
1234    K: 'ch',
1235    G: 'arks',
1236    H: 'ea',
1237    I: 'ightg',
1238    J: 'wh'
1239  };
1240  var names = {
1241    OiceXe: 'f0f8ff',
1242    antiquewEte: 'faebd7',
1243    aqua: 'ffff',
1244    aquamarRe: '7fffd4',
1245    azuY: 'f0ffff',
1246    beige: 'f5f5dc',
1247    bisque: 'ffe4c4',
1248    black: '0',
1249    blanKedOmond: 'ffebcd',
1250    Xe: 'ff',
1251    XeviTet: '8a2be2',
1252    bPwn: 'a52a2a',
1253    burlywood: 'deb887',
1254    caMtXe: '5f9ea0',
1255    KartYuse: '7fff00',
1256    KocTate: 'd2691e',
1257    cSO: 'ff7f50',
1258    cSnflowerXe: '6495ed',
1259    cSnsilk: 'fff8dc',
1260    crimson: 'dc143c',
1261    cyan: 'ffff',
1262    xXe: '8b',
1263    xcyan: '8b8b',
1264    xgTMnPd: 'b8860b',
1265    xWay: 'a9a9a9',
1266    xgYF: '6400',
1267    xgYy: 'a9a9a9',
1268    xkhaki: 'bdb76b',
1269    xmagFta: '8b008b',
1270    xTivegYF: '556b2f',
1271    xSange: 'ff8c00',
1272    xScEd: '9932cc',
1273    xYd: '8b0000',
1274    xsOmon: 'e9967a',
1275    xsHgYF: '8fbc8f',
1276    xUXe: '483d8b',
1277    xUWay: '2f4f4f',
1278    xUgYy: '2f4f4f',
1279    xQe: 'ced1',
1280    xviTet: '9400d3',
1281    dAppRk: 'ff1493',
1282    dApskyXe: 'bfff',
1283    dimWay: '696969',
1284    dimgYy: '696969',
1285    dodgerXe: '1e90ff',
1286    fiYbrick: 'b22222',
1287    flSOwEte: 'fffaf0',
1288    foYstWAn: '228b22',
1289    fuKsia: 'ff00ff',
1290    gaRsbSo: 'dcdcdc',
1291    ghostwEte: 'f8f8ff',
1292    gTd: 'ffd700',
1293    gTMnPd: 'daa520',
1294    Way: '808080',
1295    gYF: '8000',
1296    gYFLw: 'adff2f',
1297    gYy: '808080',
1298    honeyMw: 'f0fff0',
1299    hotpRk: 'ff69b4',
1300    RdianYd: 'cd5c5c',
1301    Rdigo: '4b0082',
1302    ivSy: 'fffff0',
1303    khaki: 'f0e68c',
1304    lavFMr: 'e6e6fa',
1305    lavFMrXsh: 'fff0f5',
1306    lawngYF: '7cfc00',
1307    NmoncEffon: 'fffacd',
1308    ZXe: 'add8e6',
1309    ZcSO: 'f08080',
1310    Zcyan: 'e0ffff',
1311    ZgTMnPdLw: 'fafad2',
1312    ZWay: 'd3d3d3',
1313    ZgYF: '90ee90',
1314    ZgYy: 'd3d3d3',
1315    ZpRk: 'ffb6c1',
1316    ZsOmon: 'ffa07a',
1317    ZsHgYF: '20b2aa',
1318    ZskyXe: '87cefa',
1319    ZUWay: '778899',
1320    ZUgYy: '778899',
1321    ZstAlXe: 'b0c4de',
1322    ZLw: 'ffffe0',
1323    lime: 'ff00',
1324    limegYF: '32cd32',
1325    lRF: 'faf0e6',
1326    magFta: 'ff00ff',
1327    maPon: '800000',
1328    VaquamarRe: '66cdaa',
1329    VXe: 'cd',
1330    VScEd: 'ba55d3',
1331    VpurpN: '9370db',
1332    VsHgYF: '3cb371',
1333    VUXe: '7b68ee',
1334    VsprRggYF: 'fa9a',
1335    VQe: '48d1cc',
1336    VviTetYd: 'c71585',
1337    midnightXe: '191970',
1338    mRtcYam: 'f5fffa',
1339    mistyPse: 'ffe4e1',
1340    moccasR: 'ffe4b5',
1341    navajowEte: 'ffdead',
1342    navy: '80',
1343    Tdlace: 'fdf5e6',
1344    Tive: '808000',
1345    TivedBb: '6b8e23',
1346    Sange: 'ffa500',
1347    SangeYd: 'ff4500',
1348    ScEd: 'da70d6',
1349    pOegTMnPd: 'eee8aa',
1350    pOegYF: '98fb98',
1351    pOeQe: 'afeeee',
1352    pOeviTetYd: 'db7093',
1353    papayawEp: 'ffefd5',
1354    pHKpuff: 'ffdab9',
1355    peru: 'cd853f',
1356    pRk: 'ffc0cb',
1357    plum: 'dda0dd',
1358    powMrXe: 'b0e0e6',
1359    purpN: '800080',
1360    YbeccapurpN: '663399',
1361    Yd: 'ff0000',
1362    Psybrown: 'bc8f8f',
1363    PyOXe: '4169e1',
1364    saddNbPwn: '8b4513',
1365    sOmon: 'fa8072',
1366    sandybPwn: 'f4a460',
1367    sHgYF: '2e8b57',
1368    sHshell: 'fff5ee',
1369    siFna: 'a0522d',
1370    silver: 'c0c0c0',
1371    skyXe: '87ceeb',
1372    UXe: '6a5acd',
1373    UWay: '708090',
1374    UgYy: '708090',
1375    snow: 'fffafa',
1376    sprRggYF: 'ff7f',
1377    stAlXe: '4682b4',
1378    tan: 'd2b48c',
1379    teO: '8080',
1380    tEstN: 'd8bfd8',
1381    tomato: 'ff6347',
1382    Qe: '40e0d0',
1383    viTet: 'ee82ee',
1384    JHt: 'f5deb3',
1385    wEte: 'ffffff',
1386    wEtesmoke: 'f5f5f5',
1387    Lw: 'ffff00',
1388    LwgYF: '9acd32'
1389  };
1390
1391  function unpack() {
1392    var unpacked = {};
1393    var keys = Object.keys(names);

1394    var tkeys = Object.keys(map$1$1);
1395    var i, j, k, ok, nk;
1396
1397    for (i = 0; i < keys.length; i++) {
1398      ok = nk = keys[i];
1399
1400      for (j = 0; j < tkeys.length; j++) {
1401        k = tkeys[j];
1402        nk = nk.replace(k, map$1$1[k]);
1403      }
1404
1405      k = parseInt(names[ok], 16);
1406      unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF];
1407    }
1408
1409    return unpacked;
1410  }
1411
1412  var names$1;
1413
1414  function nameParse(str) {
1415    if (!names$1) {
1416      names$1 = unpack();
1417      names$1.transparent = [0, 0, 0, 0];
1418    }
1419
1420    var a = names$1[str.toLowerCase()];
1421    return a && {
1422      r: a[0],
1423      g: a[1],
1424      b: a[2],
1425      a: a.length === 4 ? a[3] : 255
1426    };
1427  }
1428
1429  function modHSL(v, i, ratio) {
1430    if (v) {
1431      var tmp = rgb2hsl(v);
1432      tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1));
1433      tmp = hsl2rgb(tmp);
1434      v.r = tmp[0];
1435      v.g = tmp[1];
1436      v.b = tmp[2];
1437    }
1438  }
1439
1440  function clone(v, proto) {
1441    return v ? Object.assign(proto || {}, v) : v;
1442  }
1443
1444  function fromObject(input) {
1445    var v = {
1446      r: 0,
1447      g: 0,
1448      b: 0,
1449      a: 255
1450    };
1451
1452    if (Array.isArray(input)) {
1453      if (input.length >= 3) {
1454        v = {
1455          r: input[0],
1456          g: input[1],
1457          b: input[2],
1458          a: 255
1459        };
1460
1461        if (input.length > 3) {
1462          v.a = n2b(input[3]);
1463        }
1464      }
1465    } else {
1466      v = clone(input, {
1467        r: 0,
1468        g: 0,
1469        b: 0,
1470        a: 1
1471      });
1472      v.a = n2b(v.a);
1473    }
1474
1475    return v;
1476  }
1477
1478  function functionParse(str) {
1479    if (str.charAt(0) === 'r') {
1480      return rgbParse(str);
1481    }
1482
1483    return hueParse(str);
1484  }
1485
1486  var Color = /*#__PURE__*/function () {
1487    function Color(input) {
1488      _classCallCheck(this, Color);
1489
1490      if (input instanceof Color) {
1491        return input;
1492      }
1493
1494      var type = _typeof(input);
1495
1496      var v;
1497
1498      if (type === 'object') {
1499        v = fromObject(input);
1500      } else if (type === 'string') {
1501        v = hexParse(input) || nameParse(input) || functionParse(input);
1502      }
1503
1504      this._rgb = v;
1505      this._valid = !!v;
1506    }
1507
1508    _createClass(Color, [{
1509      key: "valid",
1510      get: function get() {
1511        return this._valid;
1512      }
1513    }, {
1514      key: "rgb",
1515      get: function get() {
1516        var v = clone(this._rgb);
1517
1518        if (v) {
1519          v.a = b2n(v.a);
1520        }
1521
1522        return v;
1523      },
1524      set: function set(obj) {
1525        this._rgb = fromObject(obj);
1526      }
1527    }, {
1528      key: "rgbString",
1529      value: function rgbString() {
1530        return this._valid ? _rgbString(this._rgb) : this._rgb;
1531      }
1532    }, {
1533      key: "hexString",
1534      value: function hexString() {
1535        return this._valid ? _hexString(this._rgb) : this._rgb;
1536      }
1537    }, {
1538      key: "hslString",
1539      value: function hslString() {
1540        return this._valid ? _hslString(this._rgb) : this._rgb;
1541      }
1542    }, {
1543      key: "mix",
1544      value: function mix(color, weight) {
1545        var me = this;
1546
1547        if (color) {
1548          var c1 = me.rgb;
1549          var c2 = color.rgb;
1550          var w2;
1551          var p = weight === w2 ? 0.5 : weight;
1552          var w = 2 * p - 1;
1553          var a = c1.a - c2.a;
1554          var w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
1555          w2 = 1 - w1;
1556          c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5;
1557          c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5;
1558          c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5;
1559          c1.a = p * c1.a + (1 - p) * c2.a;
1560          me.rgb = c1;
1561        }
1562
1563        return me;
1564      }
1565    }, {
1566      key: "clone",
1567      value: function clone() {
1568        return new Color(this.rgb);
1569      }
1570    }, {
1571      key: "alpha",
1572      value: function alpha(a) {
1573        this._rgb.a = n2b(a);
1574        return this;
1575      }
1576    }, {
1577      key: "clearer",
1578      value: function clearer(ratio) {
1579        var rgb = this._rgb;
1580        rgb.a *= 1 - ratio;
1581        return this;
1582      }
1583    }, {
1584      key: "greyscale",
1585      value: function greyscale() {
1586        var rgb = this._rgb;
1587        var val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);
1588        rgb.r = rgb.g = rgb.b = val;
1589        return this;
1590      }
1591    }, {

1592      key: "opaquer",
1593      value: function opaquer(ratio) {
1594        var rgb = this._rgb;
1595        rgb.a *= 1 + ratio;
1596        return this;
1597      }
1598    }, {
1599      key: "negate",
1600      value: function negate() {
1601        var v = this._rgb;
1602        v.r = 255 - v.r;
1603        v.g = 255 - v.g;
1604        v.b = 255 - v.b;
1605        return this;
1606      }
1607    }, {
1608      key: "lighten",
1609      value: function lighten(ratio) {
1610        modHSL(this._rgb, 2, ratio);
1611        return this;
1612      }
1613    }, {
1614      key: "darken",
1615      value: function darken(ratio) {
1616        modHSL(this._rgb, 2, -ratio);
1617        return this;
1618      }
1619    }, {
1620      key: "saturate",
1621      value: function saturate(ratio) {
1622        modHSL(this._rgb, 1, ratio);
1623        return this;
1624      }
1625    }, {
1626      key: "desaturate",
1627      value: function desaturate(ratio) {
1628        modHSL(this._rgb, 1, -ratio);
1629        return this;
1630      }
1631    }, {
1632      key: "rotate",
1633      value: function rotate(deg) {
1634        _rotate(this._rgb, deg);
1635
1636        return this;
1637      }
1638    }]);
1639
1640    return Color;
1641  }();
1642
1643  function index_esm(input) {
1644    return new Color(input);
1645  }
1646
1647  var isPatternOrGradient = function isPatternOrGradient(value) {
1648    return value instanceof CanvasGradient || value instanceof CanvasPattern;
1649  };
1650
1651  function color(value) {
1652    return isPatternOrGradient(value) ? value : index_esm(value);
1653  }
1654
1655  function getHoverColor(value) {
1656    return isPatternOrGradient(value) ? value : index_esm(value).saturate(0.5).darken(0.1).hexString();
1657  }
1658
1659  var overrides = Object.create(null);
1660  var descriptors = Object.create(null);
1661
1662  function getScope$1(node, key) {
1663    if (!key) {
1664      return node;
1665    }
1666
1667    var keys = key.split('.');
1668
1669    for (var i = 0, n = keys.length; i < n; ++i) {
1670      var k = keys[i];
1671      node = node[k] || (node[k] = Object.create(null));
1672    }
1673
1674    return node;
1675  }
1676
1677  function _set(root, scope, values) {
1678    if (typeof scope === 'string') {
1679      return merge(getScope$1(root, scope), values);
1680    }
1681
1682    return merge(getScope$1(root, ''), scope);
1683  }
1684
1685  var Defaults = /*#__PURE__*/function () {
1686    function Defaults(_descriptors) {
1687      _classCallCheck(this, Defaults);
1688
1689      this.animation = undefined;
1690      this.backgroundColor = 'rgba(0,0,0,0.1)';
1691      this.borderColor = 'rgba(0,0,0,0.1)';
1692      this.color = '#666';
1693      this.datasets = {};
1694
1695      this.devicePixelRatio = function (context) {
1696        return context.chart.platform.getDevicePixelRatio();
1697      };
1698
1699      this.elements = {};
1700      this.events = ['mousemove', 'mouseout', 'click', 'touchstart', 'touchmove'];
1701      this.font = {
1702        family: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
1703        size: 12,
1704        style: 'normal',
1705        lineHeight: 1.2,
1706        weight: null
1707      };
1708      this.hover = {};
1709
1710      this.hoverBackgroundColor = function (ctx, options) {
1711        return getHoverColor(options.backgroundColor);
1712      };
1713
1714      this.hoverBorderColor = function (ctx, options) {
1715        return getHoverColor(options.borderColor);
1716      };
1717
1718      this.hoverColor = function (ctx, options) {
1719        return getHoverColor(options.color);
1720      };
1721
1722      this.indexAxis = 'x';
1723      this.interaction = {
1724        mode: 'nearest',
1725        intersect: true
1726      };
1727      this.maintainAspectRatio = true;
1728      this.onHover = null;
1729      this.onClick = null;
1730      this.parsing = true;
1731      this.plugins = {};
1732      this.responsive = true;
1733      this.scale = undefined;
1734      this.scales = {};
1735      this.showLine = true;
1736      this.describe(_descriptors);
1737    }
1738
1739    _createClass(Defaults, [{
1740      key: "set",
1741      value: function set(scope, values) {
1742        return _set(this, scope, values);
1743      }
1744    }, {
1745      key: "get",
1746      value: function get(scope) {
1747        return getScope$1(this, scope);
1748      }
1749    }, {
1750      key: "describe",
1751      value: function describe(scope, values) {
1752        return _set(descriptors, scope, values);
1753      }
1754    }, {
1755      key: "override",
1756      value: function override(scope, values) {
1757        return _set(overrides, scope, values);
1758      }
1759    }, {
1760      key: "route",
1761      value: function route(scope, name, targetScope, targetName) {
1762        var _Object$definePropert;
1763
1764        var scopeObject = getScope$1(this, scope);
1765        var targetScopeObject = getScope$1(this, targetScope);
1766        var privateName = '_' + name;
1767        Object.defineProperties(scopeObject, (_Object$definePropert = {}, _defineProperty(_Object$definePropert, privateName, {
1768          value: scopeObject[name],
1769          writable: true
1770        }), _defineProperty(_Object$definePropert, name, {
1771          enumerable: true,
1772          get: function get() {
1773            var local = this[privateName];
1774            var target = targetScopeObject[targetName];
1775
1776            if (isObject(local)) {
1777              return Object.assign({}, target, local);
1778            }
1779
1780            return valueOrDefault(local, target);
1781          },
1782          set: function set(value) {
1783            this[privateName] = value;
1784          }
1785        }), _Object$definePropert));
1786      }
1787    }]);
1788
1789    return Defaults;
1790  }();
1791
1792  var defaults = new Defaults({
1793    _scriptable: function _scriptable(name) {
1794      return !name.startsWith('on');
1795    },
1796    _indexable: function _indexable(name) {
1797      return name !== 'events';
1798    },
1799    hover: {
1800      _fallback: 'interaction'
1801    },
1802    interaction: {
1803      _scriptable: false,
1804      _indexable: false
1805    }
1806  });
1807
1808  function toFontString(font) {
1809    if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.fam

1809ily)) {
1810      return null;
1811    }
1812
1813    return (font.style ? font.style + ' ' : '') + (font.weight ? font.weight + ' ' : '') + font.size + 'px ' + font.family;
1814  }
1815
1816  function _measureText(ctx, data, gc, longest, string) {
1817    var textWidth = data[string];
1818
1819    if (!textWidth) {
1820      textWidth = data[string] = ctx.measureText(string).width;
1821      gc.push(string);
1822    }
1823
1824    if (textWidth > longest) {
1825      longest = textWidth;
1826    }
1827
1828    return longest;
1829  }
1830
1831  function _longestText(ctx, font, arrayOfThings, cache) {
1832    cache = cache || {};
1833    var data = cache.data = cache.data || {};
1834    var gc = cache.garbageCollect = cache.garbageCollect || [];
1835
1836    if (cache.font !== font) {
1837      data = cache.data = {};
1838      gc = cache.garbageCollect = [];
1839      cache.font = font;
1840    }
1841
1842    ctx.save();
1843    ctx.font = font;
1844    var longest = 0;
1845    var ilen = arrayOfThings.length;
1846    var i, j, jlen, thing, nestedThing;
1847
1848    for (i = 0; i < ilen; i++) {
1849      thing = arrayOfThings[i];
1850
1851      if (thing !== undefined && thing !== null && isArray(thing) !== true) {
1852        longest = _measureText(ctx, data, gc, longest, thing);
1853      } else if (isArray(thing)) {
1854        for (j = 0, jlen = thing.length; j < jlen; j++) {
1855          nestedThing = thing[j];
1856
1857          if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) {
1858            longest = _measureText(ctx, data, gc, longest, nestedThing);
1859          }
1860        }
1861      }
1862    }
1863
1864    ctx.restore();
1865    var gcLen = gc.length / 2;
1866
1867    if (gcLen > arrayOfThings.length) {
1868      for (i = 0; i < gcLen; i++) {
1869        delete data[gc[i]];
1870      }
1871
1872      gc.splice(0, gcLen);
1873    }
1874
1875    return longest;
1876  }
1877
1878  function _alignPixel(chart, pixel, width) {
1879    var devicePixelRatio = chart.currentDevicePixelRatio;
1880    var halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;
1881    return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;
1882  }
1883
1884  function clearCanvas(canvas, ctx) {
1885    ctx = ctx || canvas.getContext('2d');
1886    ctx.save();
1887    ctx.resetTransform();
1888    ctx.clearRect(0, 0, canvas.width, canvas.height);
1889    ctx.restore();
1890  }
1891
1892  function drawPoint(ctx, options, x, y) {
1893    var type, xOffset, yOffset, size, cornerRadius;
1894    var style = options.pointStyle;
1895    var rotation = options.rotation;
1896    var radius = options.radius;
1897    var rad = (rotation || 0) * RAD_PER_DEG;
1898
1899    if (style && _typeof(style) === 'object') {
1900      type = style.toString();
1901
1902      if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {
1903        ctx.save();
1904        ctx.translate(x, y);
1905        ctx.rotate(rad);
1906        ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);
1907        ctx.restore();
1908        return;
1909      }
1910    }
1911
1912    if (isNaN(radius) || radius <= 0) {
1913      return;
1914    }
1915
1916    ctx.beginPath();
1917
1918    switch (style) {
1919      default:
1920        ctx.arc(x, y, radius, 0, TAU);
1921        ctx.closePath();
1922        break;
1923
1924      case 'triangle':
1925        ctx.moveTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
1926        rad += TWO_THIRDS_PI;
1927        ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
1928        rad += TWO_THIRDS_PI;
1929        ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
1930        ctx.closePath();
1931        break;
1932
1933      case 'rectRounded':
1934        cornerRadius = radius * 0.516;
1935        size = radius - cornerRadius;
1936        xOffset = Math.cos(rad + QUARTER_PI) * size;
1937        yOffset = Math.sin(rad + QUARTER_PI) * size;
1938        ctx.arc(x - xOffset, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI);
1939        ctx.arc(x + yOffset, y - xOffset, cornerRadius, rad - HALF_PI, rad);
1940        ctx.arc(x + xOffset, y + yOffset, cornerRadius, rad, rad + HALF_PI);
1941        ctx.arc(x - yOffset, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI);
1942        ctx.closePath();
1943        break;
1944
1945      case 'rect':
1946        if (!rotation) {
1947          size = Math.SQRT1_2 * radius;
1948          ctx.rect(x - size, y - size, 2 * size, 2 * size);
1949          break;
1950        }
1951
1952        rad += QUARTER_PI;
1953
1954      case 'rectRot':
1955        xOffset = Math.cos(rad) * radius;
1956        yOffset = Math.sin(rad) * radius;
1957        ctx.moveTo(x - xOffset, y - yOffset);
1958        ctx.lineTo(x + yOffset, y - xOffset);
1959        ctx.lineTo(x + xOffset, y + yOffset);
1960        ctx.lineTo(x - yOffset, y + xOffset);
1961        ctx.closePath();
1962        break;
1963
1964      case 'crossRot':
1965        rad += QUARTER_PI;
1966
1967      case 'cross':
1968        xOffset = Math.cos(rad) * radius;
1969        yOffset = Math.sin(rad) * radius;
1970        ctx.moveTo(x - xOffset, y - yOffset);
1971        ctx.lineTo(x + xOffset, y + yOffset);
1972        ctx.moveTo(x + yOffset, y - xOffset);
1973        ctx.lineTo(x - yOffset, y + xOffset);
1974        break;
1975
1976      case 'star':
1977        xOffset = Math.cos(rad) * radius;
1978        yOffset = Math.sin(rad) * radius;
1979        ctx.moveTo(x - xOffset, y - yOffset);
1980        ctx.lineTo(x + xOffset, y + yOffset);
1981        ctx.moveTo(x + yOffset, y - xOffset);
1982        ctx.lineTo(x - yOffset, y + xOffset);
1983        rad += QUARTER_PI;
1984        xOffset = Math.cos(rad) * radius;
1985        yOffset = Math.sin(rad) * radius;
1986        ctx.moveTo(x - xOffset, y - yOffset);
1987        ctx.lineTo(x + xOffset, y + yOffset);
1988        ctx.moveTo(x + yOffset, y - xOffset);
1989        ctx.lineTo(x - yOffset, y + xOffset);
1990        break;
1991
1992      case 'line':
1993        xOffset = Math.cos(rad) * radius;
1994        yOffset = Math.sin(rad) * radius;
1995        ctx.moveTo(x - xOffset, y - yOffset);
1996        ctx.lineTo(x + xOffset, y + yOffset);
1997        break;
1998
1999      case 'dash':
2000        ctx.moveTo(x, y);
2001        ctx.lineTo(x + Math.cos(rad) * radius, y + Math.sin(rad) * radius);
2002        break;
2003    }
2004
2005    ctx.fill();
2006
2007    if (options.borderWidth > 0) {
2008      ctx.stroke();
2009    }
2010  }
2011
2012  function _isPointInArea(point, area, margin) {
2013    margin = margin || 0.5;
2014    return point && point.x > area.left - margin && point.x < area.right + margin && point.y > area.top - margin && point.y < area.bottom + margin;
2015  }
2016
2017  function clipArea(ctx, area) {
2018    ctx.save();
2019    ctx.beginPath();
2020    ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);
2021    ctx.clip();
2022  }
2023
2024  function unclipArea(ctx) {
2025    ctx.restore();
2026  }
2027
2028  function _steppedLineTo(ctx, previous, target, flip, mode) {
2029    if (!previous) {
2030      return ctx.lineTo(target.x, target.y);
2031    }
2032
2033    if (mode === 'middle') {
2034      var midpoint = (previous.x + target.x) / 2.0;
2035      ctx.lineTo(midpoint, previous.y);
2036      ctx.lineTo(midpoint, target.y);
2037    } else if (mode === 'after' !== !!flip) {
2038      ctx.lineTo(previous.x, target.y);
2039    } else {
2040      ctx.lineTo(target.x, previous.y);
2041    }
2042
2043    ctx.lineTo(target.x, target.y);
2044  }
2045
2046  function _bezierCurveTo(ctx, previous, target, flip) {
2047    if (!previous) {
2048      return ctx.lineTo(target.x, target.y);
2049    }
2050
2051    ctx.bezierCurveTo(flip ? previous.cp1x : previous.cp2x, flip ? previous.cp1y : previous.cp2y, flip ? target.cp2x : target.cp1x, flip ? target.cp2y : target.cp1y, target.x, target.y);
2052  }
2053
2054  function renderText(ctx, text, x, y, font) {
2055    var opts = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
2056    var lines = isArray(text) ? text : [text];
2057    var stroke = opts.strokeWidth > 0 && opts.strokeColor !== '';
2058    var i, line;
2059    ctx.save();
2060    ctx.font = font.string;
2061    setRenderOpts(ctx, opts);
2062
2063    for (i = 0; i < lines.length; ++i) {
2064      line = lines[i];
2065
2066      if (stroke) {
2067        if (opts.strokeColor) {
2068          ctx.strokeStyle = opts.strokeColor;
2069        }
2070
2071        if (!isNullOrUndef(opts.strokeWidth)) {
2072          ctx.lineWidth = opts.strokeWidth;
2073        }
2074
2075        ctx.strokeText(line, x, y, opts.maxWidth);
2076      }
2077
2078      ctx.fillText(line, x, y, opts.maxWidth);
2079      decorateText(ctx, x, y, line, opts);
2080      y += font.lineHeight;
2081    }
2082
2083    ctx.restore();
2084  }
2085
2086  function setRenderOpts(ctx, opts) {
2087    if (opts.translation) {
2088      ctx.translate(opts.translation[0], opts.translation[1]);
2089    }
2090
2091    if (!isNullOrUndef(opts.rotation)) {
2092      ctx.rotate(opts.rotation);
2093    }
2094
2095    if (opts.color) {
2096      ctx.fillStyle = opts.color;
2097    }
2098
2099    if (opts.textAlign) {
2100      ctx.textAlign = opts.textAlign;
2101    }
2102
2103    if (opts.textBaseline) {
2104      ctx.textBaseline = opts.textBaseline;
2105    }
2106  }
2107
2108  function decorateText(ctx, x, y, line, opts) {
2109    if (opts.strikethrough || opts.underline) {
2110      var metrics = ctx.measureText(line);
2111      var left = x - metrics.actualBoundingBoxLeft;
2112      var right = x + metrics.actualBoundingBoxRight;
2113      var top = y - metrics.actualBoundingBoxAscent;
2114      var bottom = y + metrics.actualBoundingBoxDescent;
2115      var yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;
2116      ctx.strokeStyle = ctx.fillStyle;
2117      ctx.beginPath();
2118      ctx.lineWidth = opts.decorationWidth || 2;
2119      ctx.moveTo(left, yDecoration);
2120      ctx.lineTo(right, yDecoration);
2121      ctx.stroke();
2122    }
2123  }
2124
2125  function addRoundedRectPath(ctx, rect) {
2126    var x = rect.x,
2127        y = rect.y,
2128        w = rect.w,
2129        h = rect.h,
2130        radius = rect.radius;
2131    ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, -HALF_PI, PI, true);
2132    ctx.lineTo(x, y + h - radius.bottomLeft);
2133    ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);
2134    ctx.lineTo(x + w - radius.bottomRight, y + h);
2135    ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);
2136    ctx.lineTo(x + w, y + radius.topRight);
2137    ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true);
2138    ctx.lineTo(x + radius.topLeft, y);
2139  }
2140
2141  var LINE_HEIGHT = new RegExp(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);
2142  var FONT_STYLE = new RegExp(/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/);
2143
2144  function toLineHeight(value, size) {
2145    var matches = ('' + value).match(LINE_HEIGHT);
2146
2147    if (!matches || matches[1] === 'normal') {
2148      return size * 1.2;
2149    }
2150
2151    value = +matches[2];
2152
2153    switch (matches[3]) {
2154      case 'px':
2155        return value;
2156
2157      case '%':
2158        value /= 100;
2159        break;
2160    }
2161
2162    return size * value;
2163  }
2164
2165  var numberOrZero$1 = function numberOrZero(v) {
2166    return +v || 0;
2167  };
2168
2169  function _readValueToProps(value, props) {
2170    var ret = {};

2171    var objProps = isObject(props);
2172    var keys = objProps ? Object.keys(props) : props;
2173    var read = isObject(value) ? objProps ? function (prop) {
2174      return valueOrDefault(value[prop], value[props[prop]]);
2175    } : function (prop) {
2176      return value[prop];
2177    } : function () {
2178      return value;
2179    };
2180
2181    var _iterator2 = _createForOfIteratorHelper(keys),
2182        _step2;
2183
2184    try {
2185      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
2186        var prop = _step2.value;
2187        ret[prop] = numberOrZero$1(read(prop));
2188      }
2189    } catch (err) {
2190      _iterator2.e(err);
2191    } finally {
2192      _iterator2.f();
2193    }
2194
2195    return ret;
2196  }
2197
2198  function toTRBL(value) {
2199    return _readValueToProps(value, {
2200      top: 'y',
2201      right: 'x',
2202      bottom: 'y',
2203      left: 'x'
2204    });
2205  }
2206
2207  function toTRBLCorners(value) {
2208    return _readValueToProps(value, ['topLeft', 'topRight', 'bottomLeft', 'bottomRight']);
2209  }
2210
2211  function toPadding(value) {
2212    var obj = toTRBL(value);
2213    obj.width = obj.left + obj.right;
2214    obj.height = obj.top + obj.bottom;
2215    return obj;
2216  }
2217
2218  function toFont(options, fallback) {
2219    options = options || {};
2220    fallback = fallback || defaults.font;
2221    var size = valueOrDefault(options.size, fallback.size);
2222
2223    if (typeof size === 'string') {
2224      size = parseInt(size, 10);
2225    }
2226
2227    var style = valueOrDefault(options.style, fallback.style);
2228
2229    if (style && !('' + style).match(FONT_STYLE)) {
2230      console.warn('Invalid font style specified: "' + style + '"');
2231      style = '';
2232    }
2233
2234    var font = {
2235      family: valueOrDefault(options.family, fallback.family),
2236      lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),
2237      size: size,
2238      style: style,
2239      weight: valueOrDefault(options.weight, fallback.weight),
2240      string: ''
2241    };
2242    font.string = toFontString(font);
2243    return font;
2244  }
2245
2246  function resolve(inputs, context, index, info) {
2247    var cacheable = true;
2248    var i, ilen, value;
2249
2250    for (i = 0, ilen = inputs.length; i < ilen; ++i) {
2251      value = inputs[i];
2252
2253      if (value === undefined) {
2254        continue;
2255      }
2256
2257      if (context !== undefined && typeof value === 'function') {
2258        value = value(context);
2259        cacheable = false;
2260      }
2261
2262      if (index !== undefined && isArray(value)) {
2263        value = value[index % value.length];
2264        cacheable = false;
2265      }
2266
2267      if (value !== undefined) {
2268        if (info && !cacheable) {
2269          info.cacheable = false;
2270        }
2271
2272        return value;
2273      }
2274    }
2275  }
2276
2277  function _addGrace(minmax, grace) {
2278    var min = minmax.min,
2279        max = minmax.max;
2280    return {
2281      min: min - Math.abs(toDimension(grace, min)),
2282      max: max + toDimension(grace, max)
2283    };
2284  }
2285
2286  function _lookup(table, value, cmp) {
2287    cmp = cmp || function (index) {
2288      return table[index] < value;
2289    };
2290
2291    var hi = table.length - 1;
2292    var lo = 0;
2293    var mid;
2294
2295    while (hi - lo > 1) {
2296      mid = lo + hi >> 1;
2297
2298      if (cmp(mid)) {
2299        lo = mid;
2300      } else {
2301        hi = mid;
2302      }
2303    }
2304
2305    return {
2306      lo: lo,
2307      hi: hi
2308    };
2309  }
2310
2311  var _lookupByKey = function _lookupByKey(table, key, value) {
2312    return _lookup(table, value, function (index) {
2313      return table[index][key] < value;
2314    });
2315  };
2316
2317  var _rlookupByKey = function _rlookupByKey(table, key, value) {
2318    return _lookup(table, value, function (index) {
2319      return table[index][key] >= value;
2320    });
2321  };
2322
2323  function _filterBetween(values, min, max) {
2324    var start = 0;
2325    var end = values.length;
2326
2327    while (start < end && values[start] < min) {
2328      start++;
2329    }
2330
2331    while (end > start && values[end - 1] > max) {
2332      end--;
2333    }
2334
2335    return start > 0 || end < values.length ? values.slice(start, end) : values;
2336  }
2337
2338  var arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift'];
2339
2340  function listenArrayEvents(array, listener) {
2341    if (array._chartjs) {
2342      array._chartjs.listeners.push(listener);
2343
2344      return;
2345    }
2346
2347    Object.defineProperty(array, '_chartjs', {
2348      configurable: true,
2349      enumerable: false,
2350      value: {
2351        listeners: [listener]
2352      }
2353    });

2354    arrayEvents.forEach(function (key) {
2355      var method = '_onData' + _capitalize(key);
2356
2357      var base = array[key];
2358      Object.defineProperty(array, key, {
2359        configurable: true,
2360        enumerable: false,
2361        value: function value() {
2362          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
2363            args[_key2] = arguments[_key2];
2364          }
2365
2366          var res = base.apply(this, args);
2367
2368          array._chartjs.listeners.forEach(function (object) {
2369            if (typeof object[method] === 'function') {
2370              object[method].apply(object, args);
2371            }
2372          });
2373
2374          return res;
2375        }
2376      });
2377    });
2378  }
2379
2380  function unlistenArrayEvents(array, listener) {
2381    var stub = array._chartjs;
2382
2383    if (!stub) {
2384      return;
2385    }
2386
2387    var listeners = stub.listeners;
2388    var index = listeners.indexOf(listener);
2389
2390    if (index !== -1) {
2391      listeners.splice(index, 1);
2392    }
2393
2394    if (listeners.length > 0) {
2395      return;
2396    }
2397
2398    arrayEvents.forEach(function (key) {
2399      delete array[key];
2400    });
2401    delete array._chartjs;
2402  }
2403
2404  function _arrayUnique(items) {
2405    var set = new Set();
2406    var i, ilen;
2407
2408    for (i = 0, ilen = items.length; i < ilen; ++i) {
2409      set.add(items[i]);
2410    }
2411
2412    if (set.size === ilen) {
2413      return items;
2414    }
2415
2416    return Array.from(set);
2417  }
2418
2419  function _createResolver(scopes) {
2420    var _cache;
2421
2422    var prefixes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [''];
2423    var rootScopes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : scopes;
2424    var fallback = arguments.length > 3 ? arguments[3] : undefined;
2425    var getTarget = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : function () {
2426      return scopes[0];
2427    };
2428
2429    if (!defined(fallback)) {
2430      fallback = _resolve('_fallback', scopes);
2431    }
2432
2433    var cache = (_cache = {}, _defineProperty(_cache, Symbol.toStringTag, 'Object'), _defineProperty(_cache, "_cacheable", true), _defineProperty(_cache, "_scopes", scopes), _defineProperty(_cache, "_rootScopes", rootScopes), _defineProperty(_cache, "_fallback", fallback), _defineProperty(_cache, "_getTarget", getTarget), _defineProperty(_cache, "override", function override(scope) {
2434      return _createResolver([scope].concat(_toConsumableArray(scopes)), prefixes, rootScopes, fallback);
2435    }), _cache);
2436    return new Proxy(cache, {
2437      deleteProperty: function deleteProperty(target, prop) {
2438        delete target[prop];
2439        delete target._keys;
2440        delete scopes[0][prop];
2441        return true;
2442      },
2443      get: function get(target, prop) {
2444        return _cached(target, prop, function () {
2445          return _resolveWithPrefixes(prop, prefixes, scopes, target);
2446        });
2447      },
2448      getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, prop) {
2449        return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);
2450      },
2451      getPrototypeOf: function getPrototypeOf() {
2452        return Reflect.getPrototypeOf(scopes[0]);
2453      },
2454      has: function has(target, prop) {
2455        return getKeysFromAllScopes(target).includes(prop);
2456      },
2457      ownKeys: function ownKeys(target) {
2458        return getKeysFromAllScopes(target);
2459      },
2460      set: function set(target, prop, value) {
2461        var storage = target._storage || (target._storage = getTarget());
2462        storage[prop] = value;
2463        delete target[prop];
2464        delete target._keys;
2465        return true;
2466      }
2467    });
2468  }
2469
2470  function _attachContext(proxy, context, subProxy, descriptorDefaults) {
2471    var cache = {
2472      _cacheable: false,
2473      _proxy: proxy,
2474      _context: context,
2475      _subProxy: subProxy,
2476      _stack: new Set(),
2477      _descriptors: _descriptors(proxy, descriptorDefaults),
2478      setContext: function setContext(ctx) {
2479        return _attachContext(proxy, ctx, subProxy, descriptorDefaults);
2480      },
2481      override: function override(scope) {
2482        return _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults);
2483      }
2484    };
2485    return new Proxy(cache, {
2486      deleteProperty: function deleteProperty(target, prop) {
2487        delete target[prop];
2488        delete proxy[prop];
2489        return true;
2490      },
2491      get: function get(target, prop, receiver) {
2492        return _cached(target, prop, function () {
2493          return _resolveWithContext(target, prop, receiver);
2494        });
2495      },
2496      getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, prop) {
2497        return target._descriptors.allKeys ? Reflect.has(proxy, prop

2497) ? {
2498          enumerable: true,
2499          configurable: true
2500        } : undefined : Reflect.getOwnPropertyDescriptor(proxy, prop);
2501      },
2502      getPrototypeOf: function getPrototypeOf() {
2503        return Reflect.getPrototypeOf(proxy);
2504      },
2505      has: function has(target, prop) {
2506        return Reflect.has(proxy, prop);
2507      },
2508      ownKeys: function ownKeys() {
2509        return Reflect.ownKeys(proxy);
2510      },
2511      set: function set(target, prop, value) {
2512        proxy[prop] = value;
2513        delete target[prop];
2514        return true;
2515      }
2516    });
2517  }
2518
2519  function _descriptors(proxy) {
2520    var defaults = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
2521      scriptable: true,
2522      indexable: true
2523    };
2524
2525    var _proxy$_scriptable = proxy._scriptable,
2526        _scriptable = _proxy$_scriptable === void 0 ? defaults.scriptable : _proxy$_scriptable,
2527        _proxy$_indexable = proxy._indexable,
2528        _indexable = _proxy$_indexable === void 0 ? defaults.indexable : _proxy$_indexable,
2529        _proxy$_allKeys = proxy._allKeys,
2530        _allKeys = _proxy$_allKeys === void 0 ? defaults.allKeys : _proxy$_allKeys;
2531
2532    return {
2533      allKeys: _allKeys,
2534      scriptable: _scriptable,
2535      indexable: _indexable,
2536      isScriptable: isFunction(_scriptable) ? _scriptable : function () {
2537        return _scriptable;
2538      },
2539      isIndexable: isFunction(_indexable) ? _indexable : function () {
2540        return _indexable;
2541      }
2542    };
2543  }
2544
2545  var readKey = function readKey(prefix, name) {
2546    return prefix ? prefix + _capitalize(name) : name;
2547  };
2548
2549  var needsSubResolver = function needsSubResolver(prop, value) {
2550    return isObject(value) && prop !== 'adapters';
2551  };
2552
2553  function _cached(target, prop, resolve) {
2554    var value = target[prop];
2555
2556    if (defined(value)) {
2557      return value;
2558    }
2559
2560    value = resolve();
2561
2562    if (defined(value)) {
2563      target[prop] = value;
2564    }
2565
2566    return value;
2567  }
2568
2569  function _resolveWithContext(target, prop, receiver) {
2570    var _proxy = target._proxy,
2571        _context = target._context,
2572        _subProxy = target._subProxy,
2573        descriptors = target._descriptors;
2574    var value = _proxy[prop];
2575
2576    if (isFunction(value) && descriptors.isScriptable(prop)) {
2577      value = _resolveScriptable(prop, value, target, receiver);
2578    }
2579
2580    if (isArray(value) && value.length) {
2581      value = _resolveArray(prop, value, target, descriptors.isIndexable);
2582    }
2583
2584    if (needsSubResolver(prop, value)) {
2585      value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors);
2586    }
2587
2588    return value;
2589  }
2590
2591  function _resolveScriptable(prop, value, target, receiver) {
2592    var _proxy = target._proxy,
2593        _context = target._context,
2594        _subProxy = target._subProxy,
2595        _stack = target._stack;
2596
2597    if (_stack.has(prop)) {
2598      throw new Error('Recursion detected: ' + Array.from(_stack).join('->') + '->' + prop);
2599    }
2600
2601    _stack.add(prop);
2602
2603    value = value(_context, _subProxy || receiver);
2604
2605    _stack.delete(prop);
2606
2607    if (isObject(value)) {
2608      value = createSubResolver(_proxy._scopes, _proxy, prop, value);
2609    }
2610
2611    return value;
2612  }
2613
2614  function _resolveArray(prop, value, target, isIndexable) {
2615    var _proxy = target._proxy,
2616        _context = target._context,
2617        _subProxy = target._subProxy,
2618        descriptors = target._descriptors;
2619
2620    if (defined(_context.index) && isIndexable(prop)) {
2621      value = value[_context.index % value.length];
2622    } else if (isObject(value[0])) {
2623      var arr = value;
2624
2625      var scopes = _proxy._scopes.filter(function (s) {
2626        return s !== arr;
2627      });
2628
2629      value = [];
2630
2631      var _iterator3 = _createForOfIteratorHelper(arr),
2632          _step3;
2633
2634      try {
2635        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
2636          var item = _step3.value;
2637          var resolver = createSubResolver(scopes, _proxy, prop, item);
2638          value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors));
2639        }
2640      } catch (err) {
2641        _iterator3.e(err);
2642      } finally {
2643        _iterator3.f();
2644      }
2645    }
2646
2647    return value;
2648  }
2649
2650  function resolveFallback(fallback, prop, value) {
2651    return isFunction(fallback) ? fallback(prop, value) : fallback;
2652  }
2653
2654  var getScope = function getScope(key, parent) {
2655    return key === true ? parent : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined;
2656  };
2657
2658  function addScopes(set, parentScopes, key, parentFallback) {
2659    var _iterator4 = _createForOfIteratorHelper(parentScopes),
2660        _step4;
2661
2662    try {
2663      for (_iterator4.s();