git subrepo commit mailcow/src/mailcow-dockerized
subrepo: subdir: "mailcow/src/mailcow-dockerized"
merged: "308860af"
upstream: origin: "https://github.com/mailcow/mailcow-dockerized.git"
branch: "master"
commit: "3f1a5af8"
git-subrepo: version: "0.4.5"
origin: "???"
commit: "???"
Change-Id: I5d51c14b45db54fe706be40a591ddbfcea50d4b0
diff --git a/mailcow/src/mailcow-dockerized/data/web/js/build/007-chart.js b/mailcow/src/mailcow-dockerized/data/web/js/build/007-chart.js
new file mode 100644
index 0000000..5899061
--- /dev/null
+++ b/mailcow/src/mailcow-dockerized/data/web/js/build/007-chart.js
@@ -0,0 +1,13269 @@
+/*!
+ * Chart.js v3.7.1
+ * https://www.chartjs.org
+ * (c) 2022 Chart.js Contributors
+ * Released under the MIT License
+ */
+(function (global, factory) {
+typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+typeof define === 'function' && define.amd ? define(factory) :
+(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Chart = factory());
+})(this, (function () { 'use strict';
+
+function fontString(pixelSize, fontStyle, fontFamily) {
+ return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;
+}
+const requestAnimFrame = (function() {
+ if (typeof window === 'undefined') {
+ return function(callback) {
+ return callback();
+ };
+ }
+ return window.requestAnimationFrame;
+}());
+function throttled(fn, thisArg, updateFn) {
+ const updateArgs = updateFn || ((args) => Array.prototype.slice.call(args));
+ let ticking = false;
+ let args = [];
+ return function(...rest) {
+ args = updateArgs(rest);
+ if (!ticking) {
+ ticking = true;
+ requestAnimFrame.call(window, () => {
+ ticking = false;
+ fn.apply(thisArg, args);
+ });
+ }
+ };
+}
+function debounce(fn, delay) {
+ let timeout;
+ return function(...args) {
+ if (delay) {
+ clearTimeout(timeout);
+ timeout = setTimeout(fn, delay, args);
+ } else {
+ fn.apply(this, args);
+ }
+ return delay;
+ };
+}
+const _toLeftRightCenter = (align) => align === 'start' ? 'left' : align === 'end' ? 'right' : 'center';
+const _alignStartEnd = (align, start, end) => align === 'start' ? start : align === 'end' ? end : (start + end) / 2;
+const _textX = (align, left, right, rtl) => {
+ const check = rtl ? 'left' : 'right';
+ return align === check ? right : align === 'center' ? (left + right) / 2 : left;
+};
+
+class Animator {
+ constructor() {
+ this._request = null;
+ this._charts = new Map();
+ this._running = false;
+ this._lastDate = undefined;
+ }
+ _notify(chart, anims, date, type) {
+ const callbacks = anims.listeners[type];
+ const numSteps = anims.duration;
+ callbacks.forEach(fn => fn({
+ chart,
+ initial: anims.initial,
+ numSteps,
+ currentStep: Math.min(date - anims.start, numSteps)
+ }));
+ }
+ _refresh() {
+ if (this._request) {
+ return;
+ }
+ this._running = true;
+ this._request = requestAnimFrame.call(window, () => {
+ this._update();
+ this._request = null;
+ if (this._running) {
+ this._refresh();
+ }
+ });
+ }
+ _update(date = Date.now()) {
+ let remaining = 0;
+ this._charts.forEach((anims, chart) => {
+ if (!anims.running || !anims.items.length) {
+ return;
+ }
+ const items = anims.items;
+ let i = items.length - 1;
+ let draw = false;
+ let item;
+ for (; i >= 0; --i) {
+ item = items[i];
+ if (item._active) {
+ if (item._total > anims.duration) {
+ anims.duration = item._total;
+ }
+ item.tick(date);
+ draw = true;
+ } else {
+ items[i] = items[items.length - 1];
+ items.pop();
+ }
+ }
+ if (draw) {
+ chart.draw();
+ this._notify(chart, anims, date, 'progress');
+ }
+ if (!items.length) {
+ anims.running = false;
+ this._notify(chart, anims, date, 'complete');
+ anims.initial = false;
+ }
+ remaining += items.length;
+ });
+ this._lastDate = date;
+ if (remaining === 0) {
+ this._running = false;
+ }
+ }
+ _getAnims(chart) {
+ const charts = this._charts;
+ let anims = charts.get(chart);
+ if (!anims) {
+ anims = {
+ running: false,
+ initial: true,
+ items: [],
+ listeners: {
+ complete: [],
+ progress: []
+ }
+ };
+ charts.set(chart, anims);
+ }
+ return anims;
+ }
+ listen(chart, event, cb) {
+ this._getAnims(chart).listeners[event].push(cb);
+ }
+ add(chart, items) {
+ if (!items || !items.length) {
+ return;
+ }
+ this._getAnims(chart).items.push(...items);
+ }
+ has(chart) {
+ return this._getAnims(chart).items.length > 0;
+ }
+ start(chart) {
+ const anims = this._charts.get(chart);
+ if (!anims) {
+ return;
+ }
+ anims.running = true;
+ anims.start = Date.now();
+ anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0);
+ this._refresh();
+ }
+ running(chart) {
+ if (!this._running) {
+ return false;
+ }
+ const anims = this._charts.get(chart);
+ if (!anims || !anims.running || !anims.items.length) {
+ return false;
+ }
+ return true;
+ }
+ stop(chart) {
+ const anims = this._charts.get(chart);
+ if (!anims || !anims.items.length) {
+ return;
+ }
+ const items = anims.items;
+ let i = items.length - 1;
+ for (; i >= 0; --i) {
+ items[i].cancel();
+ }
+ anims.items = [];
+ this._notify(chart, anims, Date.now(), 'complete');
+ }
+ remove(chart) {
+ return this._charts.delete(chart);
+ }
+}
+var animator = new Animator();
+
+/*!
+ * @kurkle/color v0.1.9
+ * https://github.com/kurkle/color#readme
+ * (c) 2020 Jukka Kurkela
+ * Released under the MIT License
+ */
+const map$1 = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15};
+const hex = '0123456789ABCDEF';
+const h1 = (b) => hex[b & 0xF];
+const h2 = (b) => hex[(b & 0xF0) >> 4] + hex[b & 0xF];
+const eq = (b) => (((b & 0xF0) >> 4) === (b & 0xF));
+function isShort(v) {
+ return eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a);
+}
+function hexParse(str) {
+ var len = str.length;
+ var ret;
+ if (str[0] === '#') {
+ if (len === 4 || len === 5) {
+ ret = {
+ r: 255 & map$1[str[1]] * 17,
+ g: 255 & map$1[str[2]] * 17,
+ b: 255 & map$1[str[3]] * 17,
+ a: len === 5 ? map$1[str[4]] * 17 : 255
+ };
+ } else if (len === 7 || len === 9) {
+ ret = {
+ r: map$1[str[1]] << 4 | map$1[str[2]],
+ g: map$1[str[3]] << 4 | map$1[str[4]],
+ b: map$1[str[5]] << 4 | map$1[str[6]],
+ a: len === 9 ? (map$1[str[7]] << 4 | map$1[str[8]]) : 255
+ };
+ }
+ }
+ return ret;
+}
+function hexString(v) {
+ var f = isShort(v) ? h1 : h2;
+ return v
+ ? '#' + f(v.r) + f(v.g) + f(v.b) + (v.a < 255 ? f(v.a) : '')
+ : v;
+}
+function round(v) {
+ return v + 0.5 | 0;
+}
+const lim = (v, l, h) => Math.max(Math.min(v, h), l);
+function p2b(v) {
+ return lim(round(v * 2.55), 0, 255);
+}
+function n2b(v) {
+ return lim(round(v * 255), 0, 255);
+}
+function b2n(v) {
+ return lim(round(v / 2.55) / 100, 0, 1);
+}
+function n2p(v) {
+ return lim(round(v * 100), 0, 100);
+}
+const RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;
+function rgbParse(str) {
+ const m = RGB_RE.exec(str);
+ let a = 255;
+ let r, g, b;
+ if (!m) {
+ return;
+ }
+ if (m[7] !== r) {
+ const v = +m[7];
+ a = 255 & (m[8] ? p2b(v) : v * 255);
+ }
+ r = +m[1];
+ g = +m[3];
+ b = +m[5];
+ r = 255 & (m[2] ? p2b(r) : r);
+ g = 255 & (m[4] ? p2b(g) : g);
+ b = 255 & (m[6] ? p2b(b) : b);
+ return {
+ r: r,
+ g: g,
+ b: b,
+ a: a
+ };
+}
+function rgbString(v) {
+ return v && (
+ v.a < 255
+ ? `rgba(${v.r}, ${v.g}, ${v.b}, ${b2n(v.a)})`
+ : `rgb(${v.r}, ${v.g}, ${v.b})`
+ );
+}
+const HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;
+function hsl2rgbn(h, s, l) {
+ const a = s * Math.min(l, 1 - l);
+ const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+ return [f(0), f(8), f(4)];
+}
+function hsv2rgbn(h, s, v) {
+ const f = (n, k = (n + h / 60) % 6) => v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
+ return [f(5), f(3), f(1)];
+}
+function hwb2rgbn(h, w, b) {
+ const rgb = hsl2rgbn(h, 1, 0.5);
+ let i;
+ if (w + b > 1) {
+ i = 1 / (w + b);
+ w *= i;
+ b *= i;
+ }
+ for (i = 0; i < 3; i++) {
+ rgb[i] *= 1 - w - b;
+ rgb[i] += w;
+ }
+ return rgb;
+}
+function rgb2hsl(v) {
+ const range = 255;
+ const r = v.r / range;
+ const g = v.g / range;
+ const b = v.b / range;
+ const max = Math.max(r, g, b);
+ const min = Math.min(r, g, b);
+ const l = (max + min) / 2;
+ let h, s, d;
+ if (max !== min) {
+ d = max - min;
+ s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+ h = max === r
+ ? ((g - b) / d) + (g < b ? 6 : 0)
+ : max === g
+ ? (b - r) / d + 2
+ : (r - g) / d + 4;
+ h = h * 60 + 0.5;
+ }
+ return [h | 0, s || 0, l];
+}
+function calln(f, a, b, c) {
+ return (
+ Array.isArray(a)
+ ? f(a[0], a[1], a[2])
+ : f(a, b, c)
+ ).map(n2b);
+}
+function hsl2rgb(h, s, l) {
+ return calln(hsl2rgbn, h, s, l);
+}
+function hwb2rgb(h, w, b) {
+ return calln(hwb2rgbn, h, w, b);
+}
+function hsv2rgb(h, s, v) {
+ return calln(hsv2rgbn, h, s, v);
+}
+function hue(h) {
+ return (h % 360 + 360) % 360;
+}
+function hueParse(str) {
+ const m = HUE_RE.exec(str);
+ let a = 255;
+ let v;
+ if (!m) {
+ return;
+ }
+ if (m[5] !== v) {
+ a = m[6] ? p2b(+m[5]) : n2b(+m[5]);
+ }
+ const h = hue(+m[2]);
+ const p1 = +m[3] / 100;
+ const p2 = +m[4] / 100;
+ if (m[1] === 'hwb') {
+ v = hwb2rgb(h, p1, p2);
+ } else if (m[1] === 'hsv') {
+ v = hsv2rgb(h, p1, p2);
+ } else {
+ v = hsl2rgb(h, p1, p2);
+ }
+ return {
+ r: v[0],
+ g: v[1],
+ b: v[2],
+ a: a
+ };
+}
+function rotate(v, deg) {
+ var h = rgb2hsl(v);
+ h[0] = hue(h[0] + deg);
+ h = hsl2rgb(h);
+ v.r = h[0];
+ v.g = h[1];
+ v.b = h[2];
+}
+function hslString(v) {
+ if (!v) {
+ return;
+ }
+ const a = rgb2hsl(v);
+ const h = a[0];
+ const s = n2p(a[1]);
+ const l = n2p(a[2]);
+ return v.a < 255
+ ? `hsla(${h}, ${s}%, ${l}%, ${b2n(v.a)})`
+ : `hsl(${h}, ${s}%, ${l}%)`;
+}
+const map$1$1 = {
+ x: 'dark',
+ Z: 'light',
+ Y: 're',
+ X: 'blu',
+ W: 'gr',
+ V: 'medium',
+ U: 'slate',
+ A: 'ee',
+ T: 'ol',
+ S: 'or',
+ B: 'ra',
+ C: 'lateg',
+ D: 'ights',
+ R: 'in',
+ Q: 'turquois',
+ E: 'hi',
+ P: 'ro',
+ O: 'al',
+ N: 'le',
+ M: 'de',
+ L: 'yello',
+ F: 'en',
+ K: 'ch',
+ G: 'arks',
+ H: 'ea',
+ I: 'ightg',
+ J: 'wh'
+};
+const names = {
+ OiceXe: 'f0f8ff',
+ antiquewEte: 'faebd7',
+ aqua: 'ffff',
+ aquamarRe: '7fffd4',
+ azuY: 'f0ffff',
+ beige: 'f5f5dc',
+ bisque: 'ffe4c4',
+ black: '0',
+ blanKedOmond: 'ffebcd',
+ Xe: 'ff',
+ XeviTet: '8a2be2',
+ bPwn: 'a52a2a',
+ burlywood: 'deb887',
+ caMtXe: '5f9ea0',
+ KartYuse: '7fff00',
+ KocTate: 'd2691e',
+ cSO: 'ff7f50',
+ cSnflowerXe: '6495ed',
+ cSnsilk: 'fff8dc',
+ crimson: 'dc143c',
+ cyan: 'ffff',
+ xXe: '8b',
+ xcyan: '8b8b',
+ xgTMnPd: 'b8860b',
+ xWay: 'a9a9a9',
+ xgYF: '6400',
+ xgYy: 'a9a9a9',
+ xkhaki: 'bdb76b',
+ xmagFta: '8b008b',
+ xTivegYF: '556b2f',
+ xSange: 'ff8c00',
+ xScEd: '9932cc',
+ xYd: '8b0000',
+ xsOmon: 'e9967a',
+ xsHgYF: '8fbc8f',
+ xUXe: '483d8b',
+ xUWay: '2f4f4f',
+ xUgYy: '2f4f4f',
+ xQe: 'ced1',
+ xviTet: '9400d3',
+ dAppRk: 'ff1493',
+ dApskyXe: 'bfff',
+ dimWay: '696969',
+ dimgYy: '696969',
+ dodgerXe: '1e90ff',
+ fiYbrick: 'b22222',
+ flSOwEte: 'fffaf0',
+ foYstWAn: '228b22',
+ fuKsia: 'ff00ff',
+ gaRsbSo: 'dcdcdc',
+ ghostwEte: 'f8f8ff',
+ gTd: 'ffd700',
+ gTMnPd: 'daa520',
+ Way: '808080',
+ gYF: '8000',
+ gYFLw: 'adff2f',
+ gYy: '808080',
+ honeyMw: 'f0fff0',
+ hotpRk: 'ff69b4',
+ RdianYd: 'cd5c5c',
+ Rdigo: '4b0082',
+ ivSy: 'fffff0',
+ khaki: 'f0e68c',
+ lavFMr: 'e6e6fa',
+ lavFMrXsh: 'fff0f5',
+ lawngYF: '7cfc00',
+ NmoncEffon: 'fffacd',
+ ZXe: 'add8e6',
+ ZcSO: 'f08080',
+ Zcyan: 'e0ffff',
+ ZgTMnPdLw: 'fafad2',
+ ZWay: 'd3d3d3',
+ ZgYF: '90ee90',
+ ZgYy: 'd3d3d3',
+ ZpRk: 'ffb6c1',
+ ZsOmon: 'ffa07a',
+ ZsHgYF: '20b2aa',
+ ZskyXe: '87cefa',
+ ZUWay: '778899',
+ ZUgYy: '778899',
+ ZstAlXe: 'b0c4de',
+ ZLw: 'ffffe0',
+ lime: 'ff00',
+ limegYF: '32cd32',
+ lRF: 'faf0e6',
+ magFta: 'ff00ff',
+ maPon: '800000',
+ VaquamarRe: '66cdaa',
+ VXe: 'cd',
+ VScEd: 'ba55d3',
+ VpurpN: '9370db',
+ VsHgYF: '3cb371',
+ VUXe: '7b68ee',
+ VsprRggYF: 'fa9a',
+ VQe: '48d1cc',
+ VviTetYd: 'c71585',
+ midnightXe: '191970',
+ mRtcYam: 'f5fffa',
+ mistyPse: 'ffe4e1',
+ moccasR: 'ffe4b5',
+ navajowEte: 'ffdead',
+ navy: '80',
+ Tdlace: 'fdf5e6',
+ Tive: '808000',
+ TivedBb: '6b8e23',
+ Sange: 'ffa500',
+ SangeYd: 'ff4500',
+ ScEd: 'da70d6',
+ pOegTMnPd: 'eee8aa',
+ pOegYF: '98fb98',
+ pOeQe: 'afeeee',
+ pOeviTetYd: 'db7093',
+ papayawEp: 'ffefd5',
+ pHKpuff: 'ffdab9',
+ peru: 'cd853f',
+ pRk: 'ffc0cb',
+ plum: 'dda0dd',
+ powMrXe: 'b0e0e6',
+ purpN: '800080',
+ YbeccapurpN: '663399',
+ Yd: 'ff0000',
+ Psybrown: 'bc8f8f',
+ PyOXe: '4169e1',
+ saddNbPwn: '8b4513',
+ sOmon: 'fa8072',
+ sandybPwn: 'f4a460',
+ sHgYF: '2e8b57',
+ sHshell: 'fff5ee',
+ siFna: 'a0522d',
+ silver: 'c0c0c0',
+ skyXe: '87ceeb',
+ UXe: '6a5acd',
+ UWay: '708090',
+ UgYy: '708090',
+ snow: 'fffafa',
+ sprRggYF: 'ff7f',
+ stAlXe: '4682b4',
+ tan: 'd2b48c',
+ teO: '8080',
+ tEstN: 'd8bfd8',
+ tomato: 'ff6347',
+ Qe: '40e0d0',
+ viTet: 'ee82ee',
+ JHt: 'f5deb3',
+ wEte: 'ffffff',
+ wEtesmoke: 'f5f5f5',
+ Lw: 'ffff00',
+ LwgYF: '9acd32'
+};
+function unpack() {
+ const unpacked = {};
+ const keys = Object.keys(names);
+ const tkeys = Object.keys(map$1$1);
+ let i, j, k, ok, nk;
+ for (i = 0; i < keys.length; i++) {
+ ok = nk = keys[i];
+ for (j = 0; j < tkeys.length; j++) {
+ k = tkeys[j];
+ nk = nk.replace(k, map$1$1[k]);
+ }
+ k = parseInt(names[ok], 16);
+ unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF];
+ }
+ return unpacked;
+}
+let names$1;
+function nameParse(str) {
+ if (!names$1) {
+ names$1 = unpack();
+ names$1.transparent = [0, 0, 0, 0];
+ }
+ const a = names$1[str.toLowerCase()];
+ return a && {
+ r: a[0],
+ g: a[1],
+ b: a[2],
+ a: a.length === 4 ? a[3] : 255
+ };
+}
+function modHSL(v, i, ratio) {
+ if (v) {
+ let tmp = rgb2hsl(v);
+ tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1));
+ tmp = hsl2rgb(tmp);
+ v.r = tmp[0];
+ v.g = tmp[1];
+ v.b = tmp[2];
+ }
+}
+function clone$1(v, proto) {
+ return v ? Object.assign(proto || {}, v) : v;
+}
+function fromObject(input) {
+ var v = {r: 0, g: 0, b: 0, a: 255};
+ if (Array.isArray(input)) {
+ if (input.length >= 3) {
+ v = {r: input[0], g: input[1], b: input[2], a: 255};
+ if (input.length > 3) {
+ v.a = n2b(input[3]);
+ }
+ }
+ } else {
+ v = clone$1(input, {r: 0, g: 0, b: 0, a: 1});
+ v.a = n2b(v.a);
+ }
+ return v;
+}
+function functionParse(str) {
+ if (str.charAt(0) === 'r') {
+ return rgbParse(str);
+ }
+ return hueParse(str);
+}
+class Color {
+ constructor(input) {
+ if (input instanceof Color) {
+ return input;
+ }
+ const type = typeof input;
+ let v;
+ if (type === 'object') {
+ v = fromObject(input);
+ } else if (type === 'string') {
+ v = hexParse(input) || nameParse(input) || functionParse(input);
+ }
+ this._rgb = v;
+ this._valid = !!v;
+ }
+ get valid() {
+ return this._valid;
+ }
+ get rgb() {
+ var v = clone$1(this._rgb);
+ if (v) {
+ v.a = b2n(v.a);
+ }
+ return v;
+ }
+ set rgb(obj) {
+ this._rgb = fromObject(obj);
+ }
+ rgbString() {
+ return this._valid ? rgbString(this._rgb) : this._rgb;
+ }
+ hexString() {
+ return this._valid ? hexString(this._rgb) : this._rgb;
+ }
+ hslString() {
+ return this._valid ? hslString(this._rgb) : this._rgb;
+ }
+ mix(color, weight) {
+ const me = this;
+ if (color) {
+ const c1 = me.rgb;
+ const c2 = color.rgb;
+ let w2;
+ const p = weight === w2 ? 0.5 : weight;
+ const w = 2 * p - 1;
+ const a = c1.a - c2.a;
+ const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
+ w2 = 1 - w1;
+ c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5;
+ c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5;
+ c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5;
+ c1.a = p * c1.a + (1 - p) * c2.a;
+ me.rgb = c1;
+ }
+ return me;
+ }
+ clone() {
+ return new Color(this.rgb);
+ }
+ alpha(a) {
+ this._rgb.a = n2b(a);
+ return this;
+ }
+ clearer(ratio) {
+ const rgb = this._rgb;
+ rgb.a *= 1 - ratio;
+ return this;
+ }
+ greyscale() {
+ const rgb = this._rgb;
+ const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);
+ rgb.r = rgb.g = rgb.b = val;
+ return this;
+ }
+ opaquer(ratio) {
+ const rgb = this._rgb;
+ rgb.a *= 1 + ratio;
+ return this;
+ }
+ negate() {
+ const v = this._rgb;
+ v.r = 255 - v.r;
+ v.g = 255 - v.g;
+ v.b = 255 - v.b;
+ return this;
+ }
+ lighten(ratio) {
+ modHSL(this._rgb, 2, ratio);
+ return this;
+ }
+ darken(ratio) {
+ modHSL(this._rgb, 2, -ratio);
+ return this;
+ }
+ saturate(ratio) {
+ modHSL(this._rgb, 1, ratio);
+ return this;
+ }
+ desaturate(ratio) {
+ modHSL(this._rgb, 1, -ratio);
+ return this;
+ }
+ rotate(deg) {
+ rotate(this._rgb, deg);
+ return this;
+ }
+}
+function index_esm(input) {
+ return new Color(input);
+}
+
+const isPatternOrGradient = (value) => value instanceof CanvasGradient || value instanceof CanvasPattern;
+function color(value) {
+ return isPatternOrGradient(value) ? value : index_esm(value);
+}
+function getHoverColor(value) {
+ return isPatternOrGradient(value)
+ ? value
+ : index_esm(value).saturate(0.5).darken(0.1).hexString();
+}
+
+function noop() {}
+const uid = (function() {
+ let id = 0;
+ return function() {
+ return id++;
+ };
+}());
+function isNullOrUndef(value) {
+ return value === null || typeof value === 'undefined';
+}
+function isArray(value) {
+ if (Array.isArray && Array.isArray(value)) {
+ return true;
+ }
+ const type = Object.prototype.toString.call(value);
+ if (type.substr(0, 7) === '[object' && type.substr(-6) === 'Array]') {
+ return true;
+ }
+ return false;
+}
+function isObject(value) {
+ return value !== null && Object.prototype.toString.call(value) === '[object Object]';
+}
+const isNumberFinite = (value) => (typeof value === 'number' || value instanceof Number) && isFinite(+value);
+function finiteOrDefault(value, defaultValue) {
+ return isNumberFinite(value) ? value : defaultValue;
+}
+function valueOrDefault(value, defaultValue) {
+ return typeof value === 'undefined' ? defaultValue : value;
+}
+const toPercentage = (value, dimension) =>
+ typeof value === 'string' && value.endsWith('%') ?
+ parseFloat(value) / 100
+ : value / dimension;
+const toDimension = (value, dimension) =>
+ typeof value === 'string' && value.endsWith('%') ?
+ parseFloat(value) / 100 * dimension
+ : +value;
+function callback(fn, args, thisArg) {
+ if (fn && typeof fn.call === 'function') {
+ return fn.apply(thisArg, args);
+ }
+}
+function each(loopable, fn, thisArg, reverse) {
+ let i, len, keys;
+ if (isArray(loopable)) {
+ len = loopable.length;
+ if (reverse) {
+ for (i = len - 1; i >= 0; i--) {
+ fn.call(thisArg, loopable[i], i);
+ }
+ } else {
+ for (i = 0; i < len; i++) {
+ fn.call(thisArg, loopable[i], i);
+ }
+ }
+ } else if (isObject(loopable)) {
+ keys = Object.keys(loopable);
+ len = keys.length;
+ for (i = 0; i < len; i++) {
+ fn.call(thisArg, loopable[keys[i]], keys[i]);
+ }
+ }
+}
+function _elementsEqual(a0, a1) {
+ let i, ilen, v0, v1;
+ if (!a0 || !a1 || a0.length !== a1.length) {
+ return false;
+ }
+ for (i = 0, ilen = a0.length; i < ilen; ++i) {
+ v0 = a0[i];
+ v1 = a1[i];
+ if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {
+ return false;
+ }
+ }
+ return true;
+}
+function clone(source) {
+ if (isArray(source)) {
+ return source.map(clone);
+ }
+ if (isObject(source)) {
+ const target = Object.create(null);
+ const keys = Object.keys(source);
+ const klen = keys.length;
+ let k = 0;
+ for (; k < klen; ++k) {
+ target[keys[k]] = clone(source[keys[k]]);
+ }
+ return target;
+ }
+ return source;
+}
+function isValidKey(key) {
+ return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1;
+}
+function _merger(key, target, source, options) {
+ if (!isValidKey(key)) {
+ return;
+ }
+ const tval = target[key];
+ const sval = source[key];
+ if (isObject(tval) && isObject(sval)) {
+ merge(tval, sval, options);
+ } else {
+ target[key] = clone(sval);
+ }
+}
+function merge(target, source, options) {
+ const sources = isArray(source) ? source : [source];
+ const ilen = sources.length;
+ if (!isObject(target)) {
+ return target;
+ }
+ options = options || {};
+ const merger = options.merger || _merger;
+ for (let i = 0; i < ilen; ++i) {
+ source = sources[i];
+ if (!isObject(source)) {
+ continue;
+ }
+ const keys = Object.keys(source);
+ for (let k = 0, klen = keys.length; k < klen; ++k) {
+ merger(keys[k], target, source, options);
+ }
+ }
+ return target;
+}
+function mergeIf(target, source) {
+ return merge(target, source, {merger: _mergerIf});
+}
+function _mergerIf(key, target, source) {
+ if (!isValidKey(key)) {
+ return;
+ }
+ const tval = target[key];
+ const sval = source[key];
+ if (isObject(tval) && isObject(sval)) {
+ mergeIf(tval, sval);
+ } else if (!Object.prototype.hasOwnProperty.call(target, key)) {
+ target[key] = clone(sval);
+ }
+}
+function _deprecated(scope, value, previous, current) {
+ if (value !== undefined) {
+ console.warn(scope + ': "' + previous +
+ '" is deprecated. Please use "' + current + '" instead');
+ }
+}
+const emptyString = '';
+const dot = '.';
+function indexOfDotOrLength(key, start) {
+ const idx = key.indexOf(dot, start);
+ return idx === -1 ? key.length : idx;
+}
+function resolveObjectKey(obj, key) {
+ if (key === emptyString) {
+ return obj;
+ }
+ let pos = 0;
+ let idx = indexOfDotOrLength(key, pos);
+ while (obj && idx > pos) {
+ obj = obj[key.substr(pos, idx - pos)];
+ pos = idx + 1;
+ idx = indexOfDotOrLength(key, pos);
+ }
+ return obj;
+}
+function _capitalize(str) {
+ return str.charAt(0).toUpperCase() + str.slice(1);
+}
+const defined = (value) => typeof value !== 'undefined';
+const isFunction = (value) => typeof value === 'function';
+const setsEqual = (a, b) => {
+ if (a.size !== b.size) {
+ return false;
+ }
+ for (const item of a) {
+ if (!b.has(item)) {
+ return false;
+ }
+ }
+ return true;
+};
+function _isClickEvent(e) {
+ return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu';
+}
+
+const overrides = Object.create(null);
+const descriptors = Object.create(null);
+function getScope$1(node, key) {
+ if (!key) {
+ return node;
+ }
+ const keys = key.split('.');
+ for (let i = 0, n = keys.length; i < n; ++i) {
+ const k = keys[i];
+ node = node[k] || (node[k] = Object.create(null));
+ }
+ return node;
+}
+function set(root, scope, values) {
+ if (typeof scope === 'string') {
+ return merge(getScope$1(root, scope), values);
+ }
+ return merge(getScope$1(root, ''), scope);
+}
+class Defaults {
+ constructor(_descriptors) {
+ this.animation = undefined;
+ this.backgroundColor = 'rgba(0,0,0,0.1)';
+ this.borderColor = 'rgba(0,0,0,0.1)';
+ this.color = '#666';
+ this.datasets = {};
+ this.devicePixelRatio = (context) => context.chart.platform.getDevicePixelRatio();
+ this.elements = {};
+ this.events = [
+ 'mousemove',
+ 'mouseout',
+ 'click',
+ 'touchstart',
+ 'touchmove'
+ ];
+ this.font = {
+ family: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
+ size: 12,
+ style: 'normal',
+ lineHeight: 1.2,
+ weight: null
+ };
+ this.hover = {};
+ this.hoverBackgroundColor = (ctx, options) => getHoverColor(options.backgroundColor);
+ this.hoverBorderColor = (ctx, options) => getHoverColor(options.borderColor);
+ this.hoverColor = (ctx, options) => getHoverColor(options.color);
+ this.indexAxis = 'x';
+ this.interaction = {
+ mode: 'nearest',
+ intersect: true
+ };
+ this.maintainAspectRatio = true;
+ this.onHover = null;
+ this.onClick = null;
+ this.parsing = true;
+ this.plugins = {};
+ this.responsive = true;
+ this.scale = undefined;
+ this.scales = {};
+ this.showLine = true;
+ this.drawActiveElementsOnTop = true;
+ this.describe(_descriptors);
+ }
+ set(scope, values) {
+ return set(this, scope, values);
+ }
+ get(scope) {
+ return getScope$1(this, scope);
+ }
+ describe(scope, values) {
+ return set(descriptors, scope, values);
+ }
+ override(scope, values) {
+ return set(overrides, scope, values);
+ }
+ route(scope, name, targetScope, targetName) {
+ const scopeObject = getScope$1(this, scope);
+ const targetScopeObject = getScope$1(this, targetScope);
+ const privateName = '_' + name;
+ Object.defineProperties(scopeObject, {
+ [privateName]: {
+ value: scopeObject[name],
+ writable: true
+ },
+ [name]: {
+ enumerable: true,
+ get() {
+ const local = this[privateName];
+ const target = targetScopeObject[targetName];
+ if (isObject(local)) {
+ return Object.assign({}, target, local);
+ }
+ return valueOrDefault(local, target);
+ },
+ set(value) {
+ this[privateName] = value;
+ }
+ }
+ });
+ }
+}
+var defaults = new Defaults({
+ _scriptable: (name) => !name.startsWith('on'),
+ _indexable: (name) => name !== 'events',
+ hover: {
+ _fallback: 'interaction'
+ },
+ interaction: {
+ _scriptable: false,
+ _indexable: false,
+ }
+});
+
+const PI = Math.PI;
+const TAU = 2 * PI;
+const PITAU = TAU + PI;
+const INFINITY = Number.POSITIVE_INFINITY;
+const RAD_PER_DEG = PI / 180;
+const HALF_PI = PI / 2;
+const QUARTER_PI = PI / 4;
+const TWO_THIRDS_PI = PI * 2 / 3;
+const log10 = Math.log10;
+const sign = Math.sign;
+function niceNum(range) {
+ const roundedRange = Math.round(range);
+ range = almostEquals(range, roundedRange, range / 1000) ? roundedRange : range;
+ const niceRange = Math.pow(10, Math.floor(log10(range)));
+ const fraction = range / niceRange;
+ const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;
+ return niceFraction * niceRange;
+}
+function _factorize(value) {
+ const result = [];
+ const sqrt = Math.sqrt(value);
+ let i;
+ for (i = 1; i < sqrt; i++) {
+ if (value % i === 0) {
+ result.push(i);
+ result.push(value / i);
+ }
+ }
+ if (sqrt === (sqrt | 0)) {
+ result.push(sqrt);
+ }
+ result.sort((a, b) => a - b).pop();
+ return result;
+}
+function isNumber(n) {
+ return !isNaN(parseFloat(n)) && isFinite(n);
+}
+function almostEquals(x, y, epsilon) {
+ return Math.abs(x - y) < epsilon;
+}
+function almostWhole(x, epsilon) {
+ const rounded = Math.round(x);
+ return ((rounded - epsilon) <= x) && ((rounded + epsilon) >= x);
+}
+function _setMinAndMaxByKey(array, target, property) {
+ let i, ilen, value;
+ for (i = 0, ilen = array.length; i < ilen; i++) {
+ value = array[i][property];
+ if (!isNaN(value)) {
+ target.min = Math.min(target.min, value);
+ target.max = Math.max(target.max, value);
+ }
+ }
+}
+function toRadians(degrees) {
+ return degrees * (PI / 180);
+}
+function toDegrees(radians) {
+ return radians * (180 / PI);
+}
+function _decimalPlaces(x) {
+ if (!isNumberFinite(x)) {
+ return;
+ }
+ let e = 1;
+ let p = 0;
+ while (Math.round(x * e) / e !== x) {
+ e *= 10;
+ p++;
+ }
+ return p;
+}
+function getAngleFromPoint(centrePoint, anglePoint) {
+ const distanceFromXCenter = anglePoint.x - centrePoint.x;
+ const distanceFromYCenter = anglePoint.y - centrePoint.y;
+ const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);
+ let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);
+ if (angle < (-0.5 * PI)) {
+ angle += TAU;
+ }
+ return {
+ angle,
+ distance: radialDistanceFromCenter
+ };
+}
+function distanceBetweenPoints(pt1, pt2) {
+ return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
+}
+function _angleDiff(a, b) {
+ return (a - b + PITAU) % TAU - PI;
+}
+function _normalizeAngle(a) {
+ return (a % TAU + TAU) % TAU;
+}
+function _angleBetween(angle, start, end, sameAngleIsFullCircle) {
+ const a = _normalizeAngle(angle);
+ const s = _normalizeAngle(start);
+ const e = _normalizeAngle(end);
+ const angleToStart = _normalizeAngle(s - a);
+ const angleToEnd = _normalizeAngle(e - a);
+ const startToAngle = _normalizeAngle(a - s);
+ const endToAngle = _normalizeAngle(a - e);
+ return a === s || a === e || (sameAngleIsFullCircle && s === e)
+ || (angleToStart > angleToEnd && startToAngle < endToAngle);
+}
+function _limitValue(value, min, max) {
+ return Math.max(min, Math.min(max, value));
+}
+function _int16Range(value) {
+ return _limitValue(value, -32768, 32767);
+}
+function _isBetween(value, start, end, epsilon = 1e-6) {
+ return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;
+}
+
+function toFontString(font) {
+ if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {
+ return null;
+ }
+ return (font.style ? font.style + ' ' : '')
+ + (font.weight ? font.weight + ' ' : '')
+ + font.size + 'px '
+ + font.family;
+}
+function _measureText(ctx, data, gc, longest, string) {
+ let textWidth = data[string];
+ if (!textWidth) {
+ textWidth = data[string] = ctx.measureText(string).width;
+ gc.push(string);
+ }
+ if (textWidth > longest) {
+ longest = textWidth;
+ }
+ return longest;
+}
+function _longestText(ctx, font, arrayOfThings, cache) {
+ cache = cache || {};
+ let data = cache.data = cache.data || {};
+ let gc = cache.garbageCollect = cache.garbageCollect || [];
+ if (cache.font !== font) {
+ data = cache.data = {};
+ gc = cache.garbageCollect = [];
+ cache.font = font;
+ }
+ ctx.save();
+ ctx.font = font;
+ let longest = 0;
+ const ilen = arrayOfThings.length;
+ let i, j, jlen, thing, nestedThing;
+ for (i = 0; i < ilen; i++) {
+ thing = arrayOfThings[i];
+ if (thing !== undefined && thing !== null && isArray(thing) !== true) {
+ longest = _measureText(ctx, data, gc, longest, thing);
+ } else if (isArray(thing)) {
+ for (j = 0, jlen = thing.length; j < jlen; j++) {
+ nestedThing = thing[j];
+ if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) {
+ longest = _measureText(ctx, data, gc, longest, nestedThing);
+ }
+ }
+ }
+ }
+ ctx.restore();
+ const gcLen = gc.length / 2;
+ if (gcLen > arrayOfThings.length) {
+ for (i = 0; i < gcLen; i++) {
+ delete data[gc[i]];
+ }
+ gc.splice(0, gcLen);
+ }
+ return longest;
+}
+function _alignPixel(chart, pixel, width) {
+ const devicePixelRatio = chart.currentDevicePixelRatio;
+ const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;
+ return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;
+}
+function clearCanvas(canvas, ctx) {
+ ctx = ctx || canvas.getContext('2d');
+ ctx.save();
+ ctx.resetTransform();
+ ctx.clearRect(0, 0, canvas.width, canvas.height);
+ ctx.restore();
+}
+function drawPoint(ctx, options, x, y) {
+ let type, xOffset, yOffset, size, cornerRadius;
+ const style = options.pointStyle;
+ const rotation = options.rotation;
+ const radius = options.radius;
+ let rad = (rotation || 0) * RAD_PER_DEG;
+ if (style && typeof style === 'object') {
+ type = style.toString();
+ if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {
+ ctx.save();
+ ctx.translate(x, y);
+ ctx.rotate(rad);
+ ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);
+ ctx.restore();
+ return;
+ }
+ }
+ if (isNaN(radius) || radius <= 0) {
+ return;
+ }
+ ctx.beginPath();
+ switch (style) {
+ default:
+ ctx.arc(x, y, radius, 0, TAU);
+ ctx.closePath();
+ break;
+ case 'triangle':
+ ctx.moveTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
+ rad += TWO_THIRDS_PI;
+ ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
+ rad += TWO_THIRDS_PI;
+ ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);
+ ctx.closePath();
+ break;
+ case 'rectRounded':
+ cornerRadius = radius * 0.516;
+ size = radius - cornerRadius;
+ xOffset = Math.cos(rad + QUARTER_PI) * size;
+ yOffset = Math.sin(rad + QUARTER_PI) * size;
+ ctx.arc(x - xOffset, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI);
+ ctx.arc(x + yOffset, y - xOffset, cornerRadius, rad - HALF_PI, rad);
+ ctx.arc(x + xOffset, y + yOffset, cornerRadius, rad, rad + HALF_PI);
+ ctx.arc(x - yOffset, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI);
+ ctx.closePath();
+ break;
+ case 'rect':
+ if (!rotation) {
+ size = Math.SQRT1_2 * radius;
+ ctx.rect(x - size, y - size, 2 * size, 2 * size);
+ break;
+ }
+ rad += QUARTER_PI;
+ case 'rectRot':
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ ctx.moveTo(x - xOffset, y - yOffset);
+ ctx.lineTo(x + yOffset, y - xOffset);
+ ctx.lineTo(x + xOffset, y + yOffset);
+ ctx.lineTo(x - yOffset, y + xOffset);
+ ctx.closePath();
+ break;
+ case 'crossRot':
+ rad += QUARTER_PI;
+ case 'cross':
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ ctx.moveTo(x - xOffset, y - yOffset);
+ ctx.lineTo(x + xOffset, y + yOffset);
+ ctx.moveTo(x + yOffset, y - xOffset);
+ ctx.lineTo(x - yOffset, y + xOffset);
+ break;
+ case 'star':
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ ctx.moveTo(x - xOffset, y - yOffset);
+ ctx.lineTo(x + xOffset, y + yOffset);
+ ctx.moveTo(x + yOffset, y - xOffset);
+ ctx.lineTo(x - yOffset, y + xOffset);
+ rad += QUARTER_PI;
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ ctx.moveTo(x - xOffset, y - yOffset);
+ ctx.lineTo(x + xOffset, y + yOffset);
+ ctx.moveTo(x + yOffset, y - xOffset);
+ ctx.lineTo(x - yOffset, y + xOffset);
+ break;
+ case 'line':
+ xOffset = Math.cos(rad) * radius;
+ yOffset = Math.sin(rad) * radius;
+ ctx.moveTo(x - xOffset, y - yOffset);
+ ctx.lineTo(x + xOffset, y + yOffset);
+ break;
+ case 'dash':
+ ctx.moveTo(x, y);
+ ctx.lineTo(x + Math.cos(rad) * radius, y + Math.sin(rad) * radius);
+ break;
+ }
+ ctx.fill();
+ if (options.borderWidth > 0) {
+ ctx.stroke();
+ }
+}
+function _isPointInArea(point, area, margin) {
+ margin = margin || 0.5;
+ return !area || (point && point.x > area.left - margin && point.x < area.right + margin &&
+ point.y > area.top - margin && point.y < area.bottom + margin);
+}
+function clipArea(ctx, area) {
+ ctx.save();
+ ctx.beginPath();
+ ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);
+ ctx.clip();
+}
+function unclipArea(ctx) {
+ ctx.restore();
+}
+function _steppedLineTo(ctx, previous, target, flip, mode) {
+ if (!previous) {
+ return ctx.lineTo(target.x, target.y);
+ }
+ if (mode === 'middle') {
+ const midpoint = (previous.x + target.x) / 2.0;
+ ctx.lineTo(midpoint, previous.y);
+ ctx.lineTo(midpoint, target.y);
+ } else if (mode === 'after' !== !!flip) {
+ ctx.lineTo(previous.x, target.y);
+ } else {
+ ctx.lineTo(target.x, previous.y);
+ }
+ ctx.lineTo(target.x, target.y);
+}
+function _bezierCurveTo(ctx, previous, target, flip) {
+ if (!previous) {
+ return ctx.lineTo(target.x, target.y);
+ }
+ 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);
+}
+function renderText(ctx, text, x, y, font, opts = {}) {
+ const lines = isArray(text) ? text : [text];
+ const stroke = opts.strokeWidth > 0 && opts.strokeColor !== '';
+ let i, line;
+ ctx.save();
+ ctx.font = font.string;
+ setRenderOpts(ctx, opts);
+ for (i = 0; i < lines.length; ++i) {
+ line = lines[i];
+ if (stroke) {
+ if (opts.strokeColor) {
+ ctx.strokeStyle = opts.strokeColor;
+ }
+ if (!isNullOrUndef(opts.strokeWidth)) {
+ ctx.lineWidth = opts.strokeWidth;
+ }
+ ctx.strokeText(line, x, y, opts.maxWidth);
+ }
+ ctx.fillText(line, x, y, opts.maxWidth);
+ decorateText(ctx, x, y, line, opts);
+ y += font.lineHeight;
+ }
+ ctx.restore();
+}
+function setRenderOpts(ctx, opts) {
+ if (opts.translation) {
+ ctx.translate(opts.translation[0], opts.translation[1]);
+ }
+ if (!isNullOrUndef(opts.rotation)) {
+ ctx.rotate(opts.rotation);
+ }
+ if (opts.color) {
+ ctx.fillStyle = opts.color;
+ }
+ if (opts.textAlign) {
+ ctx.textAlign = opts.textAlign;
+ }
+ if (opts.textBaseline) {
+ ctx.textBaseline = opts.textBaseline;
+ }
+}
+function decorateText(ctx, x, y, line, opts) {
+ if (opts.strikethrough || opts.underline) {
+ const metrics = ctx.measureText(line);
+ const left = x - metrics.actualBoundingBoxLeft;
+ const right = x + metrics.actualBoundingBoxRight;
+ const top = y - metrics.actualBoundingBoxAscent;
+ const bottom = y + metrics.actualBoundingBoxDescent;
+ const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;
+ ctx.strokeStyle = ctx.fillStyle;
+ ctx.beginPath();
+ ctx.lineWidth = opts.decorationWidth || 2;
+ ctx.moveTo(left, yDecoration);
+ ctx.lineTo(right, yDecoration);
+ ctx.stroke();
+ }
+}
+function addRoundedRectPath(ctx, rect) {
+ const {x, y, w, h, radius} = rect;
+ ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, -HALF_PI, PI, true);
+ ctx.lineTo(x, y + h - radius.bottomLeft);
+ ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);
+ ctx.lineTo(x + w - radius.bottomRight, y + h);
+ ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);
+ ctx.lineTo(x + w, y + radius.topRight);
+ ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true);
+ ctx.lineTo(x + radius.topLeft, y);
+}
+
+function _lookup(table, value, cmp) {
+ cmp = cmp || ((index) => table[index] < value);
+ let hi = table.length - 1;
+ let lo = 0;
+ let mid;
+ while (hi - lo > 1) {
+ mid = (lo + hi) >> 1;
+ if (cmp(mid)) {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
+ return {lo, hi};
+}
+const _lookupByKey = (table, key, value) =>
+ _lookup(table, value, index => table[index][key] < value);
+const _rlookupByKey = (table, key, value) =>
+ _lookup(table, value, index => table[index][key] >= value);
+function _filterBetween(values, min, max) {
+ let start = 0;
+ let end = values.length;
+ while (start < end && values[start] < min) {
+ start++;
+ }
+ while (end > start && values[end - 1] > max) {
+ end--;
+ }
+ return start > 0 || end < values.length
+ ? values.slice(start, end)
+ : values;
+}
+const arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift'];
+function listenArrayEvents(array, listener) {
+ if (array._chartjs) {
+ array._chartjs.listeners.push(listener);
+ return;
+ }
+ Object.defineProperty(array, '_chartjs', {
+ configurable: true,
+ enumerable: false,
+ value: {
+ listeners: [listener]
+ }
+ });
+ arrayEvents.forEach((key) => {
+ const method = '_onData' + _capitalize(key);
+ const base = array[key];
+ Object.defineProperty(array, key, {
+ configurable: true,
+ enumerable: false,
+ value(...args) {
+ const res = base.apply(this, args);
+ array._chartjs.listeners.forEach((object) => {
+ if (typeof object[method] === 'function') {
+ object[method](...args);
+ }
+ });
+ return res;
+ }
+ });
+ });
+}
+function unlistenArrayEvents(array, listener) {
+ const stub = array._chartjs;
+ if (!stub) {
+ return;
+ }
+ const listeners = stub.listeners;
+ const index = listeners.indexOf(listener);
+ if (index !== -1) {
+ listeners.splice(index, 1);
+ }
+ if (listeners.length > 0) {
+ return;
+ }
+ arrayEvents.forEach((key) => {
+ delete array[key];
+ });
+ delete array._chartjs;
+}
+function _arrayUnique(items) {
+ const set = new Set();
+ let i, ilen;
+ for (i = 0, ilen = items.length; i < ilen; ++i) {
+ set.add(items[i]);
+ }
+ if (set.size === ilen) {
+ return items;
+ }
+ return Array.from(set);
+}
+
+function _isDomSupported() {
+ return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+function _getParentNode(domNode) {
+ let parent = domNode.parentNode;
+ if (parent && parent.toString() === '[object ShadowRoot]') {
+ parent = parent.host;
+ }
+ return parent;
+}
+function parseMaxStyle(styleValue, node, parentProperty) {
+ let valueInPixels;
+ if (typeof styleValue === 'string') {
+ valueInPixels = parseInt(styleValue, 10);
+ if (styleValue.indexOf('%') !== -1) {
+ valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];
+ }
+ } else {
+ valueInPixels = styleValue;
+ }
+ return valueInPixels;
+}
+const getComputedStyle = (element) => window.getComputedStyle(element, null);
+function getStyle(el, property) {
+ return getComputedStyle(el).getPropertyValue(property);
+}
+const positions = ['top', 'right', 'bottom', 'left'];
+function getPositionedStyle(styles, style, suffix) {
+ const result = {};
+ suffix = suffix ? '-' + suffix : '';
+ for (let i = 0; i < 4; i++) {
+ const pos = positions[i];
+ result[pos] = parseFloat(styles[style + '-' + pos + suffix]) || 0;
+ }
+ result.width = result.left + result.right;
+ result.height = result.top + result.bottom;
+ return result;
+}
+const useOffsetPos = (x, y, target) => (x > 0 || y > 0) && (!target || !target.shadowRoot);
+function getCanvasPosition(evt, canvas) {
+ const e = evt.native || evt;
+ const touches = e.touches;
+ const source = touches && touches.length ? touches[0] : e;
+ const {offsetX, offsetY} = source;
+ let box = false;
+ let x, y;
+ if (useOffsetPos(offsetX, offsetY, e.target)) {
+ x = offsetX;
+ y = offsetY;
+ } else {
+ const rect = canvas.getBoundingClientRect();
+ x = source.clientX - rect.left;
+ y = source.clientY - rect.top;
+ box = true;
+ }
+ return {x, y, box};
+}
+function getRelativePosition$1(evt, chart) {
+ const {canvas, currentDevicePixelRatio} = chart;
+ const style = getComputedStyle(canvas);
+ const borderBox = style.boxSizing === 'border-box';
+ const paddings = getPositionedStyle(style, 'padding');
+ const borders = getPositionedStyle(style, 'border', 'width');
+ const {x, y, box} = getCanvasPosition(evt, canvas);
+ const xOffset = paddings.left + (box && borders.left);
+ const yOffset = paddings.top + (box && borders.top);
+ let {width, height} = chart;
+ if (borderBox) {
+ width -= paddings.width + borders.width;
+ height -= paddings.height + borders.height;
+ }
+ return {
+ x: Math.round((x - xOffset) / width * canvas.width / currentDevicePixelRatio),
+ y: Math.round((y - yOffset) / height * canvas.height / currentDevicePixelRatio)
+ };
+}
+function getContainerSize(canvas, width, height) {
+ let maxWidth, maxHeight;
+ if (width === undefined || height === undefined) {
+ const container = _getParentNode(canvas);
+ if (!container) {
+ width = canvas.clientWidth;
+ height = canvas.clientHeight;
+ } else {
+ const rect = container.getBoundingClientRect();
+ const containerStyle = getComputedStyle(container);
+ const containerBorder = getPositionedStyle(containerStyle, 'border', 'width');
+ const containerPadding = getPositionedStyle(containerStyle, 'padding');
+ width = rect.width - containerPadding.width - containerBorder.width;
+ height = rect.height - containerPadding.height - containerBorder.height;
+ maxWidth = parseMaxStyle(containerStyle.maxWidth, container, 'clientWidth');
+ maxHeight = parseMaxStyle(containerStyle.maxHeight, container, 'clientHeight');
+ }
+ }
+ return {
+ width,
+ height,
+ maxWidth: maxWidth || INFINITY,
+ maxHeight: maxHeight || INFINITY
+ };
+}
+const round1 = v => Math.round(v * 10) / 10;
+function getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) {
+ const style = getComputedStyle(canvas);
+ const margins = getPositionedStyle(style, 'margin');
+ const maxWidth = parseMaxStyle(style.maxWidth, canvas, 'clientWidth') || INFINITY;
+ const maxHeight = parseMaxStyle(style.maxHeight, canvas, 'clientHeight') || INFINITY;
+ const containerSize = getContainerSize(canvas, bbWidth, bbHeight);
+ let {width, height} = containerSize;
+ if (style.boxSizing === 'content-box') {
+ const borders = getPositionedStyle(style, 'border', 'width');
+ const paddings = getPositionedStyle(style, 'padding');
+ width -= paddings.width + borders.width;
+ height -= paddings.height + borders.height;
+ }
+ width = Math.max(0, width - margins.width);
+ height = Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height - margins.height);
+ width = round1(Math.min(width, maxWidth, containerSize.maxWidth));
+ height = round1(Math.min(height, maxHeight, containerSize.maxHeight));
+ if (width && !height) {
+ height = round1(width / 2);
+ }
+ return {
+ width,
+ height
+ };
+}
+function retinaScale(chart, forceRatio, forceStyle) {
+ const pixelRatio = forceRatio || 1;
+ const deviceHeight = Math.floor(chart.height * pixelRatio);
+ const deviceWidth = Math.floor(chart.width * pixelRatio);
+ chart.height = deviceHeight / pixelRatio;
+ chart.width = deviceWidth / pixelRatio;
+ const canvas = chart.canvas;
+ if (canvas.style && (forceStyle || (!canvas.style.height && !canvas.style.width))) {
+ canvas.style.height = `${chart.height}px`;
+ canvas.style.width = `${chart.width}px`;
+ }
+ if (chart.currentDevicePixelRatio !== pixelRatio
+ || canvas.height !== deviceHeight
+ || canvas.width !== deviceWidth) {
+ chart.currentDevicePixelRatio = pixelRatio;
+ canvas.height = deviceHeight;
+ canvas.width = deviceWidth;
+ chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+ return true;
+ }
+ return false;
+}
+const supportsEventListenerOptions = (function() {
+ let passiveSupported = false;
+ try {
+ const options = {
+ get passive() {
+ passiveSupported = true;
+ return false;
+ }
+ };
+ window.addEventListener('test', null, options);
+ window.removeEventListener('test', null, options);
+ } catch (e) {
+ }
+ return passiveSupported;
+}());
+function readUsedSize(element, property) {
+ const value = getStyle(element, property);
+ const matches = value && value.match(/^(\d+)(\.\d+)?px$/);
+ return matches ? +matches[1] : undefined;
+}
+
+function getRelativePosition(e, chart) {
+ if ('native' in e) {
+ return {
+ x: e.x,
+ y: e.y
+ };
+ }
+ return getRelativePosition$1(e, chart);
+}
+function evaluateAllVisibleItems(chart, handler) {
+ const metasets = chart.getSortedVisibleDatasetMetas();
+ let index, data, element;
+ for (let i = 0, ilen = metasets.length; i < ilen; ++i) {
+ ({index, data} = metasets[i]);
+ for (let j = 0, jlen = data.length; j < jlen; ++j) {
+ element = data[j];
+ if (!element.skip) {
+ handler(element, index, j);
+ }
+ }
+ }
+}
+function binarySearch(metaset, axis, value, intersect) {
+ const {controller, data, _sorted} = metaset;
+ const iScale = controller._cachedMeta.iScale;
+ if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) {
+ const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;
+ if (!intersect) {
+ return lookupMethod(data, axis, value);
+ } else if (controller._sharedOptions) {
+ const el = data[0];
+ const range = typeof el.getRange === 'function' && el.getRange(axis);
+ if (range) {
+ const start = lookupMethod(data, axis, value - range);
+ const end = lookupMethod(data, axis, value + range);
+ return {lo: start.lo, hi: end.hi};
+ }
+ }
+ }
+ return {lo: 0, hi: data.length - 1};
+}
+function optimizedEvaluateItems(chart, axis, position, handler, intersect) {
+ const metasets = chart.getSortedVisibleDatasetMetas();
+ const value = position[axis];
+ for (let i = 0, ilen = metasets.length; i < ilen; ++i) {
+ const {index, data} = metasets[i];
+ const {lo, hi} = binarySearch(metasets[i], axis, value, intersect);
+ for (let j = lo; j <= hi; ++j) {
+ const element = data[j];
+ if (!element.skip) {
+ handler(element, index, j);
+ }
+ }
+ }
+}
+function getDistanceMetricForAxis(axis) {
+ const useX = axis.indexOf('x') !== -1;
+ const useY = axis.indexOf('y') !== -1;
+ return function(pt1, pt2) {
+ const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;
+ const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;
+ return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
+ };
+}
+function getIntersectItems(chart, position, axis, useFinalPosition) {
+ const items = [];
+ if (!_isPointInArea(position, chart.chartArea, chart._minPadding)) {
+ return items;
+ }
+ const evaluationFunc = function(element, datasetIndex, index) {
+ if (element.inRange(position.x, position.y, useFinalPosition)) {
+ items.push({element, datasetIndex, index});
+ }
+ };
+ optimizedEvaluateItems(chart, axis, position, evaluationFunc, true);
+ return items;
+}
+function getNearestRadialItems(chart, position, axis, useFinalPosition) {
+ let items = [];
+ function evaluationFunc(element, datasetIndex, index) {
+ const {startAngle, endAngle} = element.getProps(['startAngle', 'endAngle'], useFinalPosition);
+ const {angle} = getAngleFromPoint(element, {x: position.x, y: position.y});
+ if (_angleBetween(angle, startAngle, endAngle)) {
+ items.push({element, datasetIndex, index});
+ }
+ }
+ optimizedEvaluateItems(chart, axis, position, evaluationFunc);
+ return items;
+}
+function getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition) {
+ let items = [];
+ const distanceMetric = getDistanceMetricForAxis(axis);
+ let minDistance = Number.POSITIVE_INFINITY;
+ function evaluationFunc(element, datasetIndex, index) {
+ const inRange = element.inRange(position.x, position.y, useFinalPosition);
+ if (intersect && !inRange) {
+ return;
+ }
+ const center = element.getCenterPoint(useFinalPosition);
+ const pointInArea = _isPointInArea(center, chart.chartArea, chart._minPadding);
+ if (!pointInArea && !inRange) {
+ return;
+ }
+ const distance = distanceMetric(position, center);
+ if (distance < minDistance) {
+ items = [{element, datasetIndex, index}];
+ minDistance = distance;
+ } else if (distance === minDistance) {
+ items.push({element, datasetIndex, index});
+ }
+ }
+ optimizedEvaluateItems(chart, axis, position, evaluationFunc);
+ return items;
+}
+function getNearestItems(chart, position, axis, intersect, useFinalPosition) {
+ if (!_isPointInArea(position, chart.chartArea, chart._minPadding)) {
+ return [];
+ }
+ return axis === 'r' && !intersect
+ ? getNearestRadialItems(chart, position, axis, useFinalPosition)
+ : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition);
+}
+function getAxisItems(chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const items = [];
+ const axis = options.axis;
+ const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange';
+ let intersectsItem = false;
+ evaluateAllVisibleItems(chart, (element, datasetIndex, index) => {
+ if (element[rangeMethod](position[axis], useFinalPosition)) {
+ items.push({element, datasetIndex, index});
+ }
+ if (element.inRange(position.x, position.y, useFinalPosition)) {
+ intersectsItem = true;
+ }
+ });
+ if (options.intersect && !intersectsItem) {
+ return [];
+ }
+ return items;
+}
+var Interaction = {
+ modes: {
+ index(chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const axis = options.axis || 'x';
+ const items = options.intersect
+ ? getIntersectItems(chart, position, axis, useFinalPosition)
+ : getNearestItems(chart, position, axis, false, useFinalPosition);
+ const elements = [];
+ if (!items.length) {
+ return [];
+ }
+ chart.getSortedVisibleDatasetMetas().forEach((meta) => {
+ const index = items[0].index;
+ const element = meta.data[index];
+ if (element && !element.skip) {
+ elements.push({element, datasetIndex: meta.index, index});
+ }
+ });
+ return elements;
+ },
+ dataset(chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const axis = options.axis || 'xy';
+ let items = options.intersect
+ ? getIntersectItems(chart, position, axis, useFinalPosition) :
+ getNearestItems(chart, position, axis, false, useFinalPosition);
+ if (items.length > 0) {
+ const datasetIndex = items[0].datasetIndex;
+ const data = chart.getDatasetMeta(datasetIndex).data;
+ items = [];
+ for (let i = 0; i < data.length; ++i) {
+ items.push({element: data[i], datasetIndex, index: i});
+ }
+ }
+ return items;
+ },
+ point(chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const axis = options.axis || 'xy';
+ return getIntersectItems(chart, position, axis, useFinalPosition);
+ },
+ nearest(chart, e, options, useFinalPosition) {
+ const position = getRelativePosition(e, chart);
+ const axis = options.axis || 'xy';
+ return getNearestItems(chart, position, axis, options.intersect, useFinalPosition);
+ },
+ x(chart, e, options, useFinalPosition) {
+ return getAxisItems(chart, e, {axis: 'x', intersect: options.intersect}, useFinalPosition);
+ },
+ y(chart, e, options, useFinalPosition) {
+ return getAxisItems(chart, e, {axis: 'y', intersect: options.intersect}, useFinalPosition);
+ }
+ }
+};
+
+const LINE_HEIGHT = new RegExp(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);
+const FONT_STYLE = new RegExp(/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/);
+function toLineHeight(value, size) {
+ const matches = ('' + value).match(LINE_HEIGHT);
+ if (!matches || matches[1] === 'normal') {
+ return size * 1.2;
+ }
+ value = +matches[2];
+ switch (matches[3]) {
+ case 'px':
+ return value;
+ case '%':
+ value /= 100;
+ break;
+ }
+ return size * value;
+}
+const numberOrZero = v => +v || 0;
+function _readValueToProps(value, props) {
+ const ret = {};
+ const objProps = isObject(props);
+ const keys = objProps ? Object.keys(props) : props;
+ const read = isObject(value)
+ ? objProps
+ ? prop => valueOrDefault(value[prop], value[props[prop]])
+ : prop => value[prop]
+ : () => value;
+ for (const prop of keys) {
+ ret[prop] = numberOrZero(read(prop));
+ }
+ return ret;
+}
+function toTRBL(value) {
+ return _readValueToProps(value, {top: 'y', right: 'x', bottom: 'y', left: 'x'});
+}
+function toTRBLCorners(value) {
+ return _readValueToProps(value, ['topLeft', 'topRight', 'bottomLeft', 'bottomRight']);
+}
+function toPadding(value) {
+ const obj = toTRBL(value);
+ obj.width = obj.left + obj.right;
+ obj.height = obj.top + obj.bottom;
+ return obj;
+}
+function toFont(options, fallback) {
+ options = options || {};
+ fallback = fallback || defaults.font;
+ let size = valueOrDefault(options.size, fallback.size);
+ if (typeof size === 'string') {
+ size = parseInt(size, 10);
+ }
+ let style = valueOrDefault(options.style, fallback.style);
+ if (style && !('' + style).match(FONT_STYLE)) {
+ console.warn('Invalid font style specified: "' + style + '"');
+ style = '';
+ }
+ const font = {
+ family: valueOrDefault(options.family, fallback.family),
+ lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),
+ size,
+ style,
+ weight: valueOrDefault(options.weight, fallback.weight),
+ string: ''
+ };
+ font.string = toFontString(font);
+ return font;
+}
+function resolve(inputs, context, index, info) {
+ let cacheable = true;
+ let i, ilen, value;
+ for (i = 0, ilen = inputs.length; i < ilen; ++i) {
+ value = inputs[i];
+ if (value === undefined) {
+ continue;
+ }
+ if (context !== undefined && typeof value === 'function') {
+ value = value(context);
+ cacheable = false;
+ }
+ if (index !== undefined && isArray(value)) {
+ value = value[index % value.length];
+ cacheable = false;
+ }
+ if (value !== undefined) {
+ if (info && !cacheable) {
+ info.cacheable = false;
+ }
+ return value;
+ }
+ }
+}
+function _addGrace(minmax, grace, beginAtZero) {
+ const {min, max} = minmax;
+ const change = toDimension(grace, (max - min) / 2);
+ const keepZero = (value, add) => beginAtZero && value === 0 ? 0 : value + add;
+ return {
+ min: keepZero(min, -Math.abs(change)),
+ max: keepZero(max, change)
+ };
+}
+function createContext(parentContext, context) {
+ return Object.assign(Object.create(parentContext), context);
+}
+
+const STATIC_POSITIONS = ['left', 'top', 'right', 'bottom'];
+function filterByPosition(array, position) {
+ return array.filter(v => v.pos === position);
+}
+function filterDynamicPositionByAxis(array, axis) {
+ return array.filter(v => STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis);
+}
+function sortByWeight(array, reverse) {
+ return array.sort((a, b) => {
+ const v0 = reverse ? b : a;
+ const v1 = reverse ? a : b;
+ return v0.weight === v1.weight ?
+ v0.index - v1.index :
+ v0.weight - v1.weight;
+ });
+}
+function wrapBoxes(boxes) {
+ const layoutBoxes = [];
+ let i, ilen, box, pos, stack, stackWeight;
+ for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) {
+ box = boxes[i];
+ ({position: pos, options: {stack, stackWeight = 1}} = box);
+ layoutBoxes.push({
+ index: i,
+ box,
+ pos,
+ horizontal: box.isHorizontal(),
+ weight: box.weight,
+ stack: stack && (pos + stack),
+ stackWeight
+ });
+ }
+ return layoutBoxes;
+}
+function buildStacks(layouts) {
+ const stacks = {};
+ for (const wrap of layouts) {
+ const {stack, pos, stackWeight} = wrap;
+ if (!stack || !STATIC_POSITIONS.includes(pos)) {
+ continue;
+ }
+ const _stack = stacks[stack] || (stacks[stack] = {count: 0, placed: 0, weight: 0, size: 0});
+ _stack.count++;
+ _stack.weight += stackWeight;
+ }
+ return stacks;
+}
+function setLayoutDims(layouts, params) {
+ const stacks = buildStacks(layouts);
+ const {vBoxMaxWidth, hBoxMaxHeight} = params;
+ let i, ilen, layout;
+ for (i = 0, ilen = layouts.length; i < ilen; ++i) {
+ layout = layouts[i];
+ const {fullSize} = layout.box;
+ const stack = stacks[layout.stack];
+ const factor = stack && layout.stackWeight / stack.weight;
+ if (layout.horizontal) {
+ layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;
+ layout.height = hBoxMaxHeight;
+ } else {
+ layout.width = vBoxMaxWidth;
+ layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;
+ }
+ }
+ return stacks;
+}
+function buildLayoutBoxes(boxes) {
+ const layoutBoxes = wrapBoxes(boxes);
+ const fullSize = sortByWeight(layoutBoxes.filter(wrap => wrap.box.fullSize), true);
+ const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true);
+ const right = sortByWeight(filterByPosition(layoutBoxes, 'right'));
+ const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true);
+ const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom'));
+ const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x');
+ const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y');
+ return {
+ fullSize,
+ leftAndTop: left.concat(top),
+ rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),
+ chartArea: filterByPosition(layoutBoxes, 'chartArea'),
+ vertical: left.concat(right).concat(centerVertical),
+ horizontal: top.concat(bottom).concat(centerHorizontal)
+ };
+}
+function getCombinedMax(maxPadding, chartArea, a, b) {
+ return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]);
+}
+function updateMaxPadding(maxPadding, boxPadding) {
+ maxPadding.top = Math.max(maxPadding.top, boxPadding.top);
+ maxPadding.left = Math.max(maxPadding.left, boxPadding.left);
+ maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);
+ maxPadding.right = Math.max(maxPadding.right, boxPadding.right);
+}
+function updateDims(chartArea, params, layout, stacks) {
+ const {pos, box} = layout;
+ const maxPadding = chartArea.maxPadding;
+ if (!isObject(pos)) {
+ if (layout.size) {
+ chartArea[pos] -= layout.size;
+ }
+ const stack = stacks[layout.stack] || {size: 0, count: 1};
+ stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);
+ layout.size = stack.size / stack.count;
+ chartArea[pos] += layout.size;
+ }
+ if (box.getPadding) {
+ updateMaxPadding(maxPadding, box.getPadding());
+ }
+ const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right'));
+ const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom'));
+ const widthChanged = newWidth !== chartArea.w;
+ const heightChanged = newHeight !== chartArea.h;
+ chartArea.w = newWidth;
+ chartArea.h = newHeight;
+ return layout.horizontal
+ ? {same: widthChanged, other: heightChanged}
+ : {same: heightChanged, other: widthChanged};
+}
+function handleMaxPadding(chartArea) {
+ const maxPadding = chartArea.maxPadding;
+ function updatePos(pos) {
+ const change = Math.max(maxPadding[pos] - chartArea[pos], 0);
+ chartArea[pos] += change;
+ return change;
+ }
+ chartArea.y += updatePos('top');
+ chartArea.x += updatePos('left');
+ updatePos('right');
+ updatePos('bottom');
+}
+function getMargins(horizontal, chartArea) {
+ const maxPadding = chartArea.maxPadding;
+ function marginForPositions(positions) {
+ const margin = {left: 0, top: 0, right: 0, bottom: 0};
+ positions.forEach((pos) => {
+ margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);
+ });
+ return margin;
+ }
+ return horizontal
+ ? marginForPositions(['left', 'right'])
+ : marginForPositions(['top', 'bottom']);
+}
+function fitBoxes(boxes, chartArea, params, stacks) {
+ const refitBoxes = [];
+ let i, ilen, layout, box, refit, changed;
+ for (i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i) {
+ layout = boxes[i];
+ box = layout.box;
+ box.update(
+ layout.width || chartArea.w,
+ layout.height || chartArea.h,
+ getMargins(layout.horizontal, chartArea)
+ );
+ const {same, other} = updateDims(chartArea, params, layout, stacks);
+ refit |= same && refitBoxes.length;
+ changed = changed || other;
+ if (!box.fullSize) {
+ refitBoxes.push(layout);
+ }
+ }
+ return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;
+}
+function setBoxDims(box, left, top, width, height) {
+ box.top = top;
+ box.left = left;
+ box.right = left + width;
+ box.bottom = top + height;
+ box.width = width;
+ box.height = height;
+}
+function placeBoxes(boxes, chartArea, params, stacks) {
+ const userPadding = params.padding;
+ let {x, y} = chartArea;
+ for (const layout of boxes) {
+ const box = layout.box;
+ const stack = stacks[layout.stack] || {count: 1, placed: 0, weight: 1};
+ const weight = (layout.stackWeight / stack.weight) || 1;
+ if (layout.horizontal) {
+ const width = chartArea.w * weight;
+ const height = stack.size || box.height;
+ if (defined(stack.start)) {
+ y = stack.start;
+ }
+ if (box.fullSize) {
+ setBoxDims(box, userPadding.left, y, params.outerWidth - userPadding.right - userPadding.left, height);
+ } else {
+ setBoxDims(box, chartArea.left + stack.placed, y, width, height);
+ }
+ stack.start = y;
+ stack.placed += width;
+ y = box.bottom;
+ } else {
+ const height = chartArea.h * weight;
+ const width = stack.size || box.width;
+ if (defined(stack.start)) {
+ x = stack.start;
+ }
+ if (box.fullSize) {
+ setBoxDims(box, x, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);
+ } else {
+ setBoxDims(box, x, chartArea.top + stack.placed, width, height);
+ }
+ stack.start = x;
+ stack.placed += height;
+ x = box.right;
+ }
+ }
+ chartArea.x = x;
+ chartArea.y = y;
+}
+defaults.set('layout', {
+ autoPadding: true,
+ padding: {
+ top: 0,
+ right: 0,
+ bottom: 0,
+ left: 0
+ }
+});
+var layouts = {
+ addBox(chart, item) {
+ if (!chart.boxes) {
+ chart.boxes = [];
+ }
+ item.fullSize = item.fullSize || false;
+ item.position = item.position || 'top';
+ item.weight = item.weight || 0;
+ item._layers = item._layers || function() {
+ return [{
+ z: 0,
+ draw(chartArea) {
+ item.draw(chartArea);
+ }
+ }];
+ };
+ chart.boxes.push(item);
+ },
+ removeBox(chart, layoutItem) {
+ const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;
+ if (index !== -1) {
+ chart.boxes.splice(index, 1);
+ }
+ },
+ configure(chart, item, options) {
+ item.fullSize = options.fullSize;
+ item.position = options.position;
+ item.weight = options.weight;
+ },
+ update(chart, width, height, minPadding) {
+ if (!chart) {
+ return;
+ }
+ const padding = toPadding(chart.options.layout.padding);
+ const availableWidth = Math.max(width - padding.width, 0);
+ const availableHeight = Math.max(height - padding.height, 0);
+ const boxes = buildLayoutBoxes(chart.boxes);
+ const verticalBoxes = boxes.vertical;
+ const horizontalBoxes = boxes.horizontal;
+ each(chart.boxes, box => {
+ if (typeof box.beforeLayout === 'function') {
+ box.beforeLayout();
+ }
+ });
+ const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) =>
+ wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;
+ const params = Object.freeze({
+ outerWidth: width,
+ outerHeight: height,
+ padding,
+ availableWidth,
+ availableHeight,
+ vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,
+ hBoxMaxHeight: availableHeight / 2
+ });
+ const maxPadding = Object.assign({}, padding);
+ updateMaxPadding(maxPadding, toPadding(minPadding));
+ const chartArea = Object.assign({
+ maxPadding,
+ w: availableWidth,
+ h: availableHeight,
+ x: padding.left,
+ y: padding.top
+ }, padding);
+ const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);
+ fitBoxes(boxes.fullSize, chartArea, params, stacks);
+ fitBoxes(verticalBoxes, chartArea, params, stacks);
+ if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {
+ fitBoxes(verticalBoxes, chartArea, params, stacks);
+ }
+ handleMaxPadding(chartArea);
+ placeBoxes(boxes.leftAndTop, chartArea, params, stacks);
+ chartArea.x += chartArea.w;
+ chartArea.y += chartArea.h;
+ placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);
+ chart.chartArea = {
+ left: chartArea.left,
+ top: chartArea.top,
+ right: chartArea.left + chartArea.w,
+ bottom: chartArea.top + chartArea.h,
+ height: chartArea.h,
+ width: chartArea.w,
+ };
+ each(boxes.chartArea, (layout) => {
+ const box = layout.box;
+ Object.assign(box, chart.chartArea);
+ box.update(chartArea.w, chartArea.h, {left: 0, top: 0, right: 0, bottom: 0});
+ });
+ }
+};
+
+function _createResolver(scopes, prefixes = [''], rootScopes = scopes, fallback, getTarget = () => scopes[0]) {
+ if (!defined(fallback)) {
+ fallback = _resolve('_fallback', scopes);
+ }
+ const cache = {
+ [Symbol.toStringTag]: 'Object',
+ _cacheable: true,
+ _scopes: scopes,
+ _rootScopes: rootScopes,
+ _fallback: fallback,
+ _getTarget: getTarget,
+ override: (scope) => _createResolver([scope, ...scopes], prefixes, rootScopes, fallback),
+ };
+ return new Proxy(cache, {
+ deleteProperty(target, prop) {
+ delete target[prop];
+ delete target._keys;
+ delete scopes[0][prop];
+ return true;
+ },
+ get(target, prop) {
+ return _cached(target, prop,
+ () => _resolveWithPrefixes(prop, prefixes, scopes, target));
+ },
+ getOwnPropertyDescriptor(target, prop) {
+ return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);
+ },
+ getPrototypeOf() {
+ return Reflect.getPrototypeOf(scopes[0]);
+ },
+ has(target, prop) {
+ return getKeysFromAllScopes(target).includes(prop);
+ },
+ ownKeys(target) {
+ return getKeysFromAllScopes(target);
+ },
+ set(target, prop, value) {
+ const storage = target._storage || (target._storage = getTarget());
+ target[prop] = storage[prop] = value;
+ delete target._keys;
+ return true;
+ }
+ });
+}
+function _attachContext(proxy, context, subProxy, descriptorDefaults) {
+ const cache = {
+ _cacheable: false,
+ _proxy: proxy,
+ _context: context,
+ _subProxy: subProxy,
+ _stack: new Set(),
+ _descriptors: _descriptors(proxy, descriptorDefaults),
+ setContext: (ctx) => _attachContext(proxy, ctx, subProxy, descriptorDefaults),
+ override: (scope) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)
+ };
+ return new Proxy(cache, {
+ deleteProperty(target, prop) {
+ delete target[prop];
+ delete proxy[prop];
+ return true;
+ },
+ get(target, prop, receiver) {
+ return _cached(target, prop,
+ () => _resolveWithContext(target, prop, receiver));
+ },
+ getOwnPropertyDescriptor(target, prop) {
+ return target._descriptors.allKeys
+ ? Reflect.has(proxy, prop) ? {enumerable: true, configurable: true} : undefined
+ : Reflect.getOwnPropertyDescriptor(proxy, prop);
+ },
+ getPrototypeOf() {
+ return Reflect.getPrototypeOf(proxy);
+ },
+ has(target, prop) {
+ return Reflect.has(proxy, prop);
+ },
+ ownKeys() {
+ return Reflect.ownKeys(proxy);
+ },
+ set(target, prop, value) {
+ proxy[prop] = value;
+ delete target[prop];
+ return true;
+ }
+ });
+}
+function _descriptors(proxy, defaults = {scriptable: true, indexable: true}) {
+ const {_scriptable = defaults.scriptable, _indexable = defaults.indexable, _allKeys = defaults.allKeys} = proxy;
+ return {
+ allKeys: _allKeys,
+ scriptable: _scriptable,
+ indexable: _indexable,
+ isScriptable: isFunction(_scriptable) ? _scriptable : () => _scriptable,
+ isIndexable: isFunction(_indexable) ? _indexable : () => _indexable
+ };
+}
+const readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name;
+const needsSubResolver = (prop, value) => isObject(value) && prop !== 'adapters' &&
+ (Object.getPrototypeOf(value) === null || value.constructor === Object);
+function _cached(target, prop, resolve) {
+ if (Object.prototype.hasOwnProperty.call(target, prop)) {
+ return target[prop];
+ }
+ const value = resolve();
+ target[prop] = value;
+ return value;
+}
+function _resolveWithContext(target, prop, receiver) {
+ const {_proxy, _context, _subProxy, _descriptors: descriptors} = target;
+ let value = _proxy[prop];
+ if (isFunction(value) && descriptors.isScriptable(prop)) {
+ value = _resolveScriptable(prop, value, target, receiver);
+ }
+ if (isArray(value) && value.length) {
+ value = _resolveArray(prop, value, target, descriptors.isIndexable);
+ }
+ if (needsSubResolver(prop, value)) {
+ value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors);
+ }
+ return value;
+}
+function _resolveScriptable(prop, value, target, receiver) {
+ const {_proxy, _context, _subProxy, _stack} = target;
+ if (_stack.has(prop)) {
+ throw new Error('Recursion detected: ' + Array.from(_stack).join('->') + '->' + prop);
+ }
+ _stack.add(prop);
+ value = value(_context, _subProxy || receiver);
+ _stack.delete(prop);
+ if (needsSubResolver(prop, value)) {
+ value = createSubResolver(_proxy._scopes, _proxy, prop, value);
+ }
+ return value;
+}
+function _resolveArray(prop, value, target, isIndexable) {
+ const {_proxy, _context, _subProxy, _descriptors: descriptors} = target;
+ if (defined(_context.index) && isIndexable(prop)) {
+ value = value[_context.index % value.length];
+ } else if (isObject(value[0])) {
+ const arr = value;
+ const scopes = _proxy._scopes.filter(s => s !== arr);
+ value = [];
+ for (const item of arr) {
+ const resolver = createSubResolver(scopes, _proxy, prop, item);
+ value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors));
+ }
+ }
+ return value;
+}
+function resolveFallback(fallback, prop, value) {
+ return isFunction(fallback) ? fallback(prop, value) : fallback;
+}
+const getScope = (key, parent) => key === true ? parent
+ : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined;
+function addScopes(set, parentScopes, key, parentFallback, value) {
+ for (const parent of parentScopes) {
+ const scope = getScope(key, parent);
+ if (scope) {
+ set.add(scope);
+ const fallback = resolveFallback(scope._fallback, key, value);
+ if (defined(fallback) && fallback !== key && fallback !== parentFallback) {
+ return fallback;
+ }
+ } else if (scope === false && defined(parentFallback) && key !== parentFallback) {
+ return null;
+ }
+ }
+ return false;
+}
+function createSubResolver(parentScopes, resolver, prop, value) {
+ const rootScopes = resolver._rootScopes;
+ const fallback = resolveFallback(resolver._fallback, prop, value);
+ const allScopes = [...parentScopes, ...rootScopes];
+ const set = new Set();
+ set.add(value);
+ let key = addScopesFromKey(set, allScopes, prop, fallback || prop, value);
+ if (key === null) {
+ return false;
+ }
+ if (defined(fallback) && fallback !== prop) {
+ key = addScopesFromKey(set, allScopes, fallback, key, value);
+ if (key === null) {
+ return false;
+ }
+ }
+ return _createResolver(Array.from(set), [''], rootScopes, fallback,
+ () => subGetTarget(resolver, prop, value));
+}
+function addScopesFromKey(set, allScopes, key, fallback, item) {
+ while (key) {
+ key = addScopes(set, allScopes, key, fallback, item);
+ }
+ return key;
+}
+function subGetTarget(resolver, prop, value) {
+ const parent = resolver._getTarget();
+ if (!(prop in parent)) {
+ parent[prop] = {};
+ }
+ const target = parent[prop];
+ if (isArray(target) && isObject(value)) {
+ return value;
+ }
+ return target;
+}
+function _resolveWithPrefixes(prop, prefixes, scopes, proxy) {
+ let value;
+ for (const prefix of prefixes) {
+ value = _resolve(readKey(prefix, prop), scopes);
+ if (defined(value)) {
+ return needsSubResolver(prop, value)
+ ? createSubResolver(scopes, proxy, prop, value)
+ : value;
+ }
+ }
+}
+function _resolve(key, scopes) {
+ for (const scope of scopes) {
+ if (!scope) {
+ continue;
+ }
+ const value = scope[key];
+ if (defined(value)) {
+ return value;
+ }
+ }
+}
+function getKeysFromAllScopes(target) {
+ let keys = target._keys;
+ if (!keys) {
+ keys = target._keys = resolveKeysFromAllScopes(target._scopes);
+ }
+ return keys;
+}
+function resolveKeysFromAllScopes(scopes) {
+ const set = new Set();
+ for (const scope of scopes) {
+ for (const key of Object.keys(scope).filter(k => !k.startsWith('_'))) {
+ set.add(key);
+ }
+ }
+ return Array.from(set);
+}
+
+const EPSILON = Number.EPSILON || 1e-14;
+const getPoint = (points, i) => i < points.length && !points[i].skip && points[i];
+const getValueAxis = (indexAxis) => indexAxis === 'x' ? 'y' : 'x';
+function splineCurve(firstPoint, middlePoint, afterPoint, t) {
+ const previous = firstPoint.skip ? middlePoint : firstPoint;
+ const current = middlePoint;
+ const next = afterPoint.skip ? middlePoint : afterPoint;
+ const d01 = distanceBetweenPoints(current, previous);
+ const d12 = distanceBetweenPoints(next, current);
+ let s01 = d01 / (d01 + d12);
+ let s12 = d12 / (d01 + d12);
+ s01 = isNaN(s01) ? 0 : s01;
+ s12 = isNaN(s12) ? 0 : s12;
+ const fa = t * s01;
+ const fb = t * s12;
+ return {
+ previous: {
+ x: current.x - fa * (next.x - previous.x),
+ y: current.y - fa * (next.y - previous.y)
+ },
+ next: {
+ x: current.x + fb * (next.x - previous.x),
+ y: current.y + fb * (next.y - previous.y)
+ }
+ };
+}
+function monotoneAdjust(points, deltaK, mK) {
+ const pointsLen = points.length;
+ let alphaK, betaK, tauK, squaredMagnitude, pointCurrent;
+ let pointAfter = getPoint(points, 0);
+ for (let i = 0; i < pointsLen - 1; ++i) {
+ pointCurrent = pointAfter;
+ pointAfter = getPoint(points, i + 1);
+ if (!pointCurrent || !pointAfter) {
+ continue;
+ }
+ if (almostEquals(deltaK[i], 0, EPSILON)) {
+ mK[i] = mK[i + 1] = 0;
+ continue;
+ }
+ alphaK = mK[i] / deltaK[i];
+ betaK = mK[i + 1] / deltaK[i];
+ squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);
+ if (squaredMagnitude <= 9) {
+ continue;
+ }
+ tauK = 3 / Math.sqrt(squaredMagnitude);
+ mK[i] = alphaK * tauK * deltaK[i];
+ mK[i + 1] = betaK * tauK * deltaK[i];
+ }
+}
+function monotoneCompute(points, mK, indexAxis = 'x') {
+ const valueAxis = getValueAxis(indexAxis);
+ const pointsLen = points.length;
+ let delta, pointBefore, pointCurrent;
+ let pointAfter = getPoint(points, 0);
+ for (let i = 0; i < pointsLen; ++i) {
+ pointBefore = pointCurrent;
+ pointCurrent = pointAfter;
+ pointAfter = getPoint(points, i + 1);
+ if (!pointCurrent) {
+ continue;
+ }
+ const iPixel = pointCurrent[indexAxis];
+ const vPixel = pointCurrent[valueAxis];
+ if (pointBefore) {
+ delta = (iPixel - pointBefore[indexAxis]) / 3;
+ pointCurrent[`cp1${indexAxis}`] = iPixel - delta;
+ pointCurrent[`cp1${valueAxis}`] = vPixel - delta * mK[i];
+ }
+ if (pointAfter) {
+ delta = (pointAfter[indexAxis] - iPixel) / 3;
+ pointCurrent[`cp2${indexAxis}`] = iPixel + delta;
+ pointCurrent[`cp2${valueAxis}`] = vPixel + delta * mK[i];
+ }
+ }
+}
+function splineCurveMonotone(points, indexAxis = 'x') {
+ const valueAxis = getValueAxis(indexAxis);
+ const pointsLen = points.length;
+ const deltaK = Array(pointsLen).fill(0);
+ const mK = Array(pointsLen);
+ let i, pointBefore, pointCurrent;
+ let pointAfter = getPoint(points, 0);
+ for (i = 0; i < pointsLen; ++i) {
+ pointBefore = pointCurrent;
+ pointCurrent = pointAfter;
+ pointAfter = getPoint(points, i + 1);
+ if (!pointCurrent) {
+ continue;
+ }
+ if (pointAfter) {
+ const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis];
+ deltaK[i] = slopeDelta !== 0 ? (pointAfter[valueAxis] - pointCurrent[valueAxis]) / slopeDelta : 0;
+ }
+ mK[i] = !pointBefore ? deltaK[i]
+ : !pointAfter ? deltaK[i - 1]
+ : (sign(deltaK[i - 1]) !== sign(deltaK[i])) ? 0
+ : (deltaK[i - 1] + deltaK[i]) / 2;
+ }
+ monotoneAdjust(points, deltaK, mK);
+ monotoneCompute(points, mK, indexAxis);
+}
+function capControlPoint(pt, min, max) {
+ return Math.max(Math.min(pt, max), min);
+}
+function capBezierPoints(points, area) {
+ let i, ilen, point, inArea, inAreaPrev;
+ let inAreaNext = _isPointInArea(points[0], area);
+ for (i = 0, ilen = points.length; i < ilen; ++i) {
+ inAreaPrev = inArea;
+ inArea = inAreaNext;
+ inAreaNext = i < ilen - 1 && _isPointInArea(points[i + 1], area);
+ if (!inArea) {
+ continue;
+ }
+ point = points[i];
+ if (inAreaPrev) {
+ point.cp1x = capControlPoint(point.cp1x, area.left, area.right);
+ point.cp1y = capControlPoint(point.cp1y, area.top, area.bottom);
+ }
+ if (inAreaNext) {
+ point.cp2x = capControlPoint(point.cp2x, area.left, area.right);
+ point.cp2y = capControlPoint(point.cp2y, area.top, area.bottom);
+ }
+ }
+}
+function _updateBezierControlPoints(points, options, area, loop, indexAxis) {
+ let i, ilen, point, controlPoints;
+ if (options.spanGaps) {
+ points = points.filter((pt) => !pt.skip);
+ }
+ if (options.cubicInterpolationMode === 'monotone') {
+ splineCurveMonotone(points, indexAxis);
+ } else {
+ let prev = loop ? points[points.length - 1] : points[0];
+ for (i = 0, ilen = points.length; i < ilen; ++i) {
+ point = points[i];
+ controlPoints = splineCurve(
+ prev,
+ point,
+ points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen],
+ options.tension
+ );
+ point.cp1x = controlPoints.previous.x;
+ point.cp1y = controlPoints.previous.y;
+ point.cp2x = controlPoints.next.x;
+ point.cp2y = controlPoints.next.y;
+ prev = point;
+ }
+ }
+ if (options.capBezierPoints) {
+ capBezierPoints(points, area);
+ }
+}
+
+const atEdge = (t) => t === 0 || t === 1;
+const elasticIn = (t, s, p) => -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p));
+const elasticOut = (t, s, p) => Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1;
+const effects = {
+ linear: t => t,
+ easeInQuad: t => t * t,
+ easeOutQuad: t => -t * (t - 2),
+ easeInOutQuad: t => ((t /= 0.5) < 1)
+ ? 0.5 * t * t
+ : -0.5 * ((--t) * (t - 2) - 1),
+ easeInCubic: t => t * t * t,
+ easeOutCubic: t => (t -= 1) * t * t + 1,
+ easeInOutCubic: t => ((t /= 0.5) < 1)
+ ? 0.5 * t * t * t
+ : 0.5 * ((t -= 2) * t * t + 2),
+ easeInQuart: t => t * t * t * t,
+ easeOutQuart: t => -((t -= 1) * t * t * t - 1),
+ easeInOutQuart: t => ((t /= 0.5) < 1)
+ ? 0.5 * t * t * t * t
+ : -0.5 * ((t -= 2) * t * t * t - 2),
+ easeInQuint: t => t * t * t * t * t,
+ easeOutQuint: t => (t -= 1) * t * t * t * t + 1,
+ easeInOutQuint: t => ((t /= 0.5) < 1)
+ ? 0.5 * t * t * t * t * t
+ : 0.5 * ((t -= 2) * t * t * t * t + 2),
+ easeInSine: t => -Math.cos(t * HALF_PI) + 1,
+ easeOutSine: t => Math.sin(t * HALF_PI),
+ easeInOutSine: t => -0.5 * (Math.cos(PI * t) - 1),
+ easeInExpo: t => (t === 0) ? 0 : Math.pow(2, 10 * (t - 1)),
+ easeOutExpo: t => (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1,
+ easeInOutExpo: t => 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),
+ easeInCirc: t => (t >= 1) ? t : -(Math.sqrt(1 - t * t) - 1),
+ easeOutCirc: t => Math.sqrt(1 - (t -= 1) * t),
+ easeInOutCirc: t => ((t /= 0.5) < 1)
+ ? -0.5 * (Math.sqrt(1 - t * t) - 1)
+ : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1),
+ easeInElastic: t => atEdge(t) ? t : elasticIn(t, 0.075, 0.3),
+ easeOutElastic: t => atEdge(t) ? t : elasticOut(t, 0.075, 0.3),
+ easeInOutElastic(t) {
+ const s = 0.1125;
+ const p = 0.45;
+ return atEdge(t) ? t :
+ t < 0.5
+ ? 0.5 * elasticIn(t * 2, s, p)
+ : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p);
+ },
+ easeInBack(t) {
+ const s = 1.70158;
+ return t * t * ((s + 1) * t - s);
+ },
+ easeOutBack(t) {
+ const s = 1.70158;
+ return (t -= 1) * t * ((s + 1) * t + s) + 1;
+ },
+ easeInOutBack(t) {
+ let s = 1.70158;
+ if ((t /= 0.5) < 1) {
+ return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s));
+ }
+ return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2);
+ },
+ easeInBounce: t => 1 - effects.easeOutBounce(1 - t),
+ easeOutBounce(t) {
+ const m = 7.5625;
+ const d = 2.75;
+ if (t < (1 / d)) {
+ return m * t * t;
+ }
+ if (t < (2 / d)) {
+ return m * (t -= (1.5 / d)) * t + 0.75;
+ }
+ if (t < (2.5 / d)) {
+ return m * (t -= (2.25 / d)) * t + 0.9375;
+ }
+ return m * (t -= (2.625 / d)) * t + 0.984375;
+ },
+ easeInOutBounce: t => (t < 0.5)
+ ? effects.easeInBounce(t * 2) * 0.5
+ : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5,
+};
+
+function _pointInLine(p1, p2, t, mode) {
+ return {
+ x: p1.x + t * (p2.x - p1.x),
+ y: p1.y + t * (p2.y - p1.y)
+ };
+}
+function _steppedInterpolation(p1, p2, t, mode) {
+ return {
+ x: p1.x + t * (p2.x - p1.x),
+ y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y
+ : mode === 'after' ? t < 1 ? p1.y : p2.y
+ : t > 0 ? p2.y : p1.y
+ };
+}
+function _bezierInterpolation(p1, p2, t, mode) {
+ const cp1 = {x: p1.cp2x, y: p1.cp2y};
+ const cp2 = {x: p2.cp1x, y: p2.cp1y};
+ const a = _pointInLine(p1, cp1, t);
+ const b = _pointInLine(cp1, cp2, t);
+ const c = _pointInLine(cp2, p2, t);
+ const d = _pointInLine(a, b, t);
+ const e = _pointInLine(b, c, t);
+ return _pointInLine(d, e, t);
+}
+
+const intlCache = new Map();
+function getNumberFormat(locale, options) {
+ options = options || {};
+ const cacheKey = locale + JSON.stringify(options);
+ let formatter = intlCache.get(cacheKey);
+ if (!formatter) {
+ formatter = new Intl.NumberFormat(locale, options);
+ intlCache.set(cacheKey, formatter);
+ }
+ return formatter;
+}
+function formatNumber(num, locale, options) {
+ return getNumberFormat(locale, options).format(num);
+}
+
+const getRightToLeftAdapter = function(rectX, width) {
+ return {
+ x(x) {
+ return rectX + rectX + width - x;
+ },
+ setWidth(w) {
+ width = w;
+ },
+ textAlign(align) {
+ if (align === 'center') {
+ return align;
+ }
+ return align === 'right' ? 'left' : 'right';
+ },
+ xPlus(x, value) {
+ return x - value;
+ },
+ leftForLtr(x, itemWidth) {
+ return x - itemWidth;
+ },
+ };
+};
+const getLeftToRightAdapter = function() {
+ return {
+ x(x) {
+ return x;
+ },
+ setWidth(w) {
+ },
+ textAlign(align) {
+ return align;
+ },
+ xPlus(x, value) {
+ return x + value;
+ },
+ leftForLtr(x, _itemWidth) {
+ return x;
+ },
+ };
+};
+function getRtlAdapter(rtl, rectX, width) {
+ return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();
+}
+function overrideTextDirection(ctx, direction) {
+ let style, original;
+ if (direction === 'ltr' || direction === 'rtl') {
+ style = ctx.canvas.style;
+ original = [
+ style.getPropertyValue('direction'),
+ style.getPropertyPriority('direction'),
+ ];
+ style.setProperty('direction', direction, 'important');
+ ctx.prevTextDirection = original;
+ }
+}
+function restoreTextDirection(ctx, original) {
+ if (original !== undefined) {
+ delete ctx.prevTextDirection;
+ ctx.canvas.style.setProperty('direction', original[0], original[1]);
+ }
+}
+
+function propertyFn(property) {
+ if (property === 'angle') {
+ return {
+ between: _angleBetween,
+ compare: _angleDiff,
+ normalize: _normalizeAngle,
+ };
+ }
+ return {
+ between: _isBetween,
+ compare: (a, b) => a - b,
+ normalize: x => x
+ };
+}
+function normalizeSegment({start, end, count, loop, style}) {
+ return {
+ start: start % count,
+ end: end % count,
+ loop: loop && (end - start + 1) % count === 0,
+ style
+ };
+}
+function getSegment(segment, points, bounds) {
+ const {property, start: startBound, end: endBound} = bounds;
+ const {between, normalize} = propertyFn(property);
+ const count = points.length;
+ let {start, end, loop} = segment;
+ let i, ilen;
+ if (loop) {
+ start += count;
+ end += count;
+ for (i = 0, ilen = count; i < ilen; ++i) {
+ if (!between(normalize(points[start % count][property]), startBound, endBound)) {
+ break;
+ }
+ start--;
+ end--;
+ }
+ start %= count;
+ end %= count;
+ }
+ if (end < start) {
+ end += count;
+ }
+ return {start, end, loop, style: segment.style};
+}
+function _boundSegment(segment, points, bounds) {
+ if (!bounds) {
+ return [segment];
+ }
+ const {property, start: startBound, end: endBound} = bounds;
+ const count = points.length;
+ const {compare, between, normalize} = propertyFn(property);
+ const {start, end, loop, style} = getSegment(segment, points, bounds);
+ const result = [];
+ let inside = false;
+ let subStart = null;
+ let value, point, prevValue;
+ const startIsBefore = () => between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0;
+ const endIsBefore = () => compare(endBound, value) === 0 || between(endBound, prevValue, value);
+ const shouldStart = () => inside || startIsBefore();
+ const shouldStop = () => !inside || endIsBefore();
+ for (let i = start, prev = start; i <= end; ++i) {
+ point = points[i % count];
+ if (point.skip) {
+ continue;
+ }
+ value = normalize(point[property]);
+ if (value === prevValue) {
+ continue;
+ }
+ inside = between(value, startBound, endBound);
+ if (subStart === null && shouldStart()) {
+ subStart = compare(value, startBound) === 0 ? i : prev;
+ }
+ if (subStart !== null && shouldStop()) {
+ result.push(normalizeSegment({start: subStart, end: i, loop, count, style}));
+ subStart = null;
+ }
+ prev = i;
+ prevValue = value;
+ }
+ if (subStart !== null) {
+ result.push(normalizeSegment({start: subStart, end, loop, count, style}));
+ }
+ return result;
+}
+function _boundSegments(line, bounds) {
+ const result = [];
+ const segments = line.segments;
+ for (let i = 0; i < segments.length; i++) {
+ const sub = _boundSegment(segments[i], line.points, bounds);
+ if (sub.length) {
+ result.push(...sub);
+ }
+ }
+ return result;
+}
+function findStartAndEnd(points, count, loop, spanGaps) {
+ let start = 0;
+ let end = count - 1;
+ if (loop && !spanGaps) {
+ while (start < count && !points[start].skip) {
+ start++;
+ }
+ }
+ while (start < count && points[start].skip) {
+ start++;
+ }
+ start %= count;
+ if (loop) {
+ end += start;
+ }
+ while (end > start && points[end % count].skip) {
+ end--;
+ }
+ end %= count;
+ return {start, end};
+}
+function solidSegments(points, start, max, loop) {
+ const count = points.length;
+ const result = [];
+ let last = start;
+ let prev = points[start];
+ let end;
+ for (end = start + 1; end <= max; ++end) {
+ const cur = points[end % count];
+ if (cur.skip || cur.stop) {
+ if (!prev.skip) {
+ loop = false;
+ result.push({start: start % count, end: (end - 1) % count, loop});
+ start = last = cur.stop ? end : null;
+ }
+ } else {
+ last = end;
+ if (prev.skip) {
+ start = end;
+ }
+ }
+ prev = cur;
+ }
+ if (last !== null) {
+ result.push({start: start % count, end: last % count, loop});
+ }
+ return result;
+}
+function _computeSegments(line, segmentOptions) {
+ const points = line.points;
+ const spanGaps = line.options.spanGaps;
+ const count = points.length;
+ if (!count) {
+ return [];
+ }
+ const loop = !!line._loop;
+ const {start, end} = findStartAndEnd(points, count, loop, spanGaps);
+ if (spanGaps === true) {
+ return splitByStyles(line, [{start, end, loop}], points, segmentOptions);
+ }
+ const max = end < start ? end + count : end;
+ const completeLoop = !!line._fullLoop && start === 0 && end === count - 1;
+ return splitByStyles(line, solidSegments(points, start, max, completeLoop), points, segmentOptions);
+}
+function splitByStyles(line, segments, points, segmentOptions) {
+ if (!segmentOptions || !segmentOptions.setContext || !points) {
+ return segments;
+ }
+ return doSplitByStyles(line, segments, points, segmentOptions);
+}
+function doSplitByStyles(line, segments, points, segmentOptions) {
+ const chartContext = line._chart.getContext();
+ const baseStyle = readStyle(line.options);
+ const {_datasetIndex: datasetIndex, options: {spanGaps}} = line;
+ const count = points.length;
+ const result = [];
+ let prevStyle = baseStyle;
+ let start = segments[0].start;
+ let i = start;
+ function addStyle(s, e, l, st) {
+ const dir = spanGaps ? -1 : 1;
+ if (s === e) {
+ return;
+ }
+ s += count;
+ while (points[s % count].skip) {
+ s -= dir;
+ }
+ while (points[e % count].skip) {
+ e += dir;
+ }
+ if (s % count !== e % count) {
+ result.push({start: s % count, end: e % count, loop: l, style: st});
+ prevStyle = st;
+ start = e % count;
+ }
+ }
+ for (const segment of segments) {
+ start = spanGaps ? start : segment.start;
+ let prev = points[start % count];
+ let style;
+ for (i = start + 1; i <= segment.end; i++) {
+ const pt = points[i % count];
+ style = readStyle(segmentOptions.setContext(createContext(chartContext, {
+ type: 'segment',
+ p0: prev,
+ p1: pt,
+ p0DataIndex: (i - 1) % count,
+ p1DataIndex: i % count,
+ datasetIndex
+ })));
+ if (styleChanged(style, prevStyle)) {
+ addStyle(start, i - 1, segment.loop, prevStyle);
+ }
+ prev = pt;
+ prevStyle = style;
+ }
+ if (start < i - 1) {
+ addStyle(start, i - 1, segment.loop, prevStyle);
+ }
+ }
+ return result;
+}
+function readStyle(options) {
+ return {
+ backgroundColor: options.backgroundColor,
+ borderCapStyle: options.borderCapStyle,
+ borderDash: options.borderDash,
+ borderDashOffset: options.borderDashOffset,
+ borderJoinStyle: options.borderJoinStyle,
+ borderWidth: options.borderWidth,
+ borderColor: options.borderColor
+ };
+}
+function styleChanged(style, prevStyle) {
+ return prevStyle && JSON.stringify(style) !== JSON.stringify(prevStyle);
+}
+
+var helpers = /*#__PURE__*/Object.freeze({
+__proto__: null,
+easingEffects: effects,
+color: color,
+getHoverColor: getHoverColor,
+noop: noop,
+uid: uid,
+isNullOrUndef: isNullOrUndef,
+isArray: isArray,
+isObject: isObject,
+isFinite: isNumberFinite,
+finiteOrDefault: finiteOrDefault,
+valueOrDefault: valueOrDefault,
+toPercentage: toPercentage,
+toDimension: toDimension,
+callback: callback,
+each: each,
+_elementsEqual: _elementsEqual,
+clone: clone,
+_merger: _merger,
+merge: merge,
+mergeIf: mergeIf,
+_mergerIf: _mergerIf,
+_deprecated: _deprecated,
+resolveObjectKey: resolveObjectKey,
+_capitalize: _capitalize,
+defined: defined,
+isFunction: isFunction,
+setsEqual: setsEqual,
+_isClickEvent: _isClickEvent,
+toFontString: toFontString,
+_measureText: _measureText,
+_longestText: _longestText,
+_alignPixel: _alignPixel,
+clearCanvas: clearCanvas,
+drawPoint: drawPoint,
+_isPointInArea: _isPointInArea,
+clipArea: clipArea,
+unclipArea: unclipArea,
+_steppedLineTo: _steppedLineTo,
+_bezierCurveTo: _bezierCurveTo,
+renderText: renderText,
+addRoundedRectPath: addRoundedRectPath,
+_lookup: _lookup,
+_lookupByKey: _lookupByKey,
+_rlookupByKey: _rlookupByKey,
+_filterBetween: _filterBetween,
+listenArrayEvents: listenArrayEvents,
+unlistenArrayEvents: unlistenArrayEvents,
+_arrayUnique: _arrayUnique,
+_createResolver: _createResolver,
+_attachContext: _attachContext,
+_descriptors: _descriptors,
+splineCurve: splineCurve,
+splineCurveMonotone: splineCurveMonotone,
+_updateBezierControlPoints: _updateBezierControlPoints,
+_isDomSupported: _isDomSupported,
+_getParentNode: _getParentNode,
+getStyle: getStyle,
+getRelativePosition: getRelativePosition$1,
+getMaximumSize: getMaximumSize,
+retinaScale: retinaScale,
+supportsEventListenerOptions: supportsEventListenerOptions,
+readUsedSize: readUsedSize,
+fontString: fontString,
+requestAnimFrame: requestAnimFrame,
+throttled: throttled,
+debounce: debounce,
+_toLeftRightCenter: _toLeftRightCenter,
+_alignStartEnd: _alignStartEnd,
+_textX: _textX,
+_pointInLine: _pointInLine,
+_steppedInterpolation: _steppedInterpolation,
+_bezierInterpolation: _bezierInterpolation,
+formatNumber: formatNumber,
+toLineHeight: toLineHeight,
+_readValueToProps: _readValueToProps,
+toTRBL: toTRBL,
+toTRBLCorners: toTRBLCorners,
+toPadding: toPadding,
+toFont: toFont,
+resolve: resolve,
+_addGrace: _addGrace,
+createContext: createContext,
+PI: PI,
+TAU: TAU,
+PITAU: PITAU,
+INFINITY: INFINITY,
+RAD_PER_DEG: RAD_PER_DEG,
+HALF_PI: HALF_PI,
+QUARTER_PI: QUARTER_PI,
+TWO_THIRDS_PI: TWO_THIRDS_PI,
+log10: log10,
+sign: sign,
+niceNum: niceNum,
+_factorize: _factorize,
+isNumber: isNumber,
+almostEquals: almostEquals,
+almostWhole: almostWhole,
+_setMinAndMaxByKey: _setMinAndMaxByKey,
+toRadians: toRadians,
+toDegrees: toDegrees,
+_decimalPlaces: _decimalPlaces,
+getAngleFromPoint: getAngleFromPoint,
+distanceBetweenPoints: distanceBetweenPoints,
+_angleDiff: _angleDiff,
+_normalizeAngle: _normalizeAngle,
+_angleBetween: _angleBetween,
+_limitValue: _limitValue,
+_int16Range: _int16Range,
+_isBetween: _isBetween,
+getRtlAdapter: getRtlAdapter,
+overrideTextDirection: overrideTextDirection,
+restoreTextDirection: restoreTextDirection,
+_boundSegment: _boundSegment,
+_boundSegments: _boundSegments,
+_computeSegments: _computeSegments
+});
+
+class BasePlatform {
+ acquireContext(canvas, aspectRatio) {}
+ releaseContext(context) {
+ return false;
+ }
+ addEventListener(chart, type, listener) {}
+ removeEventListener(chart, type, listener) {}
+ getDevicePixelRatio() {
+ return 1;
+ }
+ getMaximumSize(element, width, height, aspectRatio) {
+ width = Math.max(0, width || element.width);
+ height = height || element.height;
+ return {
+ width,
+ height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)
+ };
+ }
+ isAttached(canvas) {
+ return true;
+ }
+ updateConfig(config) {
+ }
+}
+
+class BasicPlatform extends BasePlatform {
+ acquireContext(item) {
+ return item && item.getContext && item.getContext('2d') || null;
+ }
+ updateConfig(config) {
+ config.options.animation = false;
+ }
+}
+
+const EXPANDO_KEY = '$chartjs';
+const EVENT_TYPES = {
+ touchstart: 'mousedown',
+ touchmove: 'mousemove',
+ touchend: 'mouseup',
+ pointerenter: 'mouseenter',
+ pointerdown: 'mousedown',
+ pointermove: 'mousemove',
+ pointerup: 'mouseup',
+ pointerleave: 'mouseout',
+ pointerout: 'mouseout'
+};
+const isNullOrEmpty = value => value === null || value === '';
+function initCanvas(canvas, aspectRatio) {
+ const style = canvas.style;
+ const renderHeight = canvas.getAttribute('height');
+ const renderWidth = canvas.getAttribute('width');
+ canvas[EXPANDO_KEY] = {
+ initial: {
+ height: renderHeight,
+ width: renderWidth,
+ style: {
+ display: style.display,
+ height: style.height,
+ width: style.width
+ }
+ }
+ };
+ style.display = style.display || 'block';
+ style.boxSizing = style.boxSizing || 'border-box';
+ if (isNullOrEmpty(renderWidth)) {
+ const displayWidth = readUsedSize(canvas, 'width');
+ if (displayWidth !== undefined) {
+ canvas.width = displayWidth;
+ }
+ }
+ if (isNullOrEmpty(renderHeight)) {
+ if (canvas.style.height === '') {
+ canvas.height = canvas.width / (aspectRatio || 2);
+ } else {
+ const displayHeight = readUsedSize(canvas, 'height');
+ if (displayHeight !== undefined) {
+ canvas.height = displayHeight;
+ }
+ }
+ }
+ return canvas;
+}
+const eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false;
+function addListener(node, type, listener) {
+ node.addEventListener(type, listener, eventListenerOptions);
+}
+function removeListener(chart, type, listener) {
+ chart.canvas.removeEventListener(type, listener, eventListenerOptions);
+}
+function fromNativeEvent(event, chart) {
+ const type = EVENT_TYPES[event.type] || event.type;
+ const {x, y} = getRelativePosition$1(event, chart);
+ return {
+ type,
+ chart,
+ native: event,
+ x: x !== undefined ? x : null,
+ y: y !== undefined ? y : null,
+ };
+}
+function nodeListContains(nodeList, canvas) {
+ for (const node of nodeList) {
+ if (node === canvas || node.contains(canvas)) {
+ return true;
+ }
+ }
+}
+function createAttachObserver(chart, type, listener) {
+ const canvas = chart.canvas;
+ const observer = new MutationObserver(entries => {
+ let trigger = false;
+ for (const entry of entries) {
+ trigger = trigger || nodeListContains(entry.addedNodes, canvas);
+ trigger = trigger && !nodeListContains(entry.removedNodes, canvas);
+ }
+ if (trigger) {
+ listener();
+ }
+ });
+ observer.observe(document, {childList: true, subtree: true});
+ return observer;
+}
+function createDetachObserver(chart, type, listener) {
+ const canvas = chart.canvas;
+ const observer = new MutationObserver(entries => {
+ let trigger = false;
+ for (const entry of entries) {
+ trigger = trigger || nodeListContains(entry.removedNodes, canvas);
+ trigger = trigger && !nodeListContains(entry.addedNodes, canvas);
+ }
+ if (trigger) {
+ listener();
+ }
+ });
+ observer.observe(document, {childList: true, subtree: true});
+ return observer;
+}
+const drpListeningCharts = new Map();
+let oldDevicePixelRatio = 0;
+function onWindowResize() {
+ const dpr = window.devicePixelRatio;
+ if (dpr === oldDevicePixelRatio) {
+ return;
+ }
+ oldDevicePixelRatio = dpr;
+ drpListeningCharts.forEach((resize, chart) => {
+ if (chart.currentDevicePixelRatio !== dpr) {
+ resize();
+ }
+ });
+}
+function listenDevicePixelRatioChanges(chart, resize) {
+ if (!drpListeningCharts.size) {
+ window.addEventListener('resize', onWindowResize);
+ }
+ drpListeningCharts.set(chart, resize);
+}
+function unlistenDevicePixelRatioChanges(chart) {
+ drpListeningCharts.delete(chart);
+ if (!drpListeningCharts.size) {
+ window.removeEventListener('resize', onWindowResize);
+ }
+}
+function createResizeObserver(chart, type, listener) {
+ const canvas = chart.canvas;
+ const container = canvas && _getParentNode(canvas);
+ if (!container) {
+ return;
+ }
+ const resize = throttled((width, height) => {
+ const w = container.clientWidth;
+ listener(width, height);
+ if (w < container.clientWidth) {
+ listener();
+ }
+ }, window);
+ const observer = new ResizeObserver(entries => {
+ const entry = entries[0];
+ const width = entry.contentRect.width;
+ const height = entry.contentRect.height;
+ if (width === 0 && height === 0) {
+ return;
+ }
+ resize(width, height);
+ });
+ observer.observe(container);
+ listenDevicePixelRatioChanges(chart, resize);
+ return observer;
+}
+function releaseObserver(chart, type, observer) {
+ if (observer) {
+ observer.disconnect();
+ }
+ if (type === 'resize') {
+ unlistenDevicePixelRatioChanges(chart);
+ }
+}
+function createProxyAndListen(chart, type, listener) {
+ const canvas = chart.canvas;
+ const proxy = throttled((event) => {
+ if (chart.ctx !== null) {
+ listener(fromNativeEvent(event, chart));
+ }
+ }, chart, (args) => {
+ const event = args[0];
+ return [event, event.offsetX, event.offsetY];
+ });
+ addListener(canvas, type, proxy);
+ return proxy;
+}
+class DomPlatform extends BasePlatform {
+ acquireContext(canvas, aspectRatio) {
+ const context = canvas && canvas.getContext && canvas.getContext('2d');
+ if (context && context.canvas === canvas) {
+ initCanvas(canvas, aspectRatio);
+ return context;
+ }
+ return null;
+ }
+ releaseContext(context) {
+ const canvas = context.canvas;
+ if (!canvas[EXPANDO_KEY]) {
+ return false;
+ }
+ const initial = canvas[EXPANDO_KEY].initial;
+ ['height', 'width'].forEach((prop) => {
+ const value = initial[prop];
+ if (isNullOrUndef(value)) {
+ canvas.removeAttribute(prop);
+ } else {
+ canvas.setAttribute(prop, value);
+ }
+ });
+ const style = initial.style || {};
+ Object.keys(style).forEach((key) => {
+ canvas.style[key] = style[key];
+ });
+ canvas.width = canvas.width;
+ delete canvas[EXPANDO_KEY];
+ return true;
+ }
+ addEventListener(chart, type, listener) {
+ this.removeEventListener(chart, type);
+ const proxies = chart.$proxies || (chart.$proxies = {});
+ const handlers = {
+ attach: createAttachObserver,
+ detach: createDetachObserver,
+ resize: createResizeObserver
+ };
+ const handler = handlers[type] || createProxyAndListen;
+ proxies[type] = handler(chart, type, listener);
+ }
+ removeEventListener(chart, type) {
+ const proxies = chart.$proxies || (chart.$proxies = {});
+ const proxy = proxies[type];
+ if (!proxy) {
+ return;
+ }
+ const handlers = {
+ attach: releaseObserver,
+ detach: releaseObserver,
+ resize: releaseObserver
+ };
+ const handler = handlers[type] || removeListener;
+ handler(chart, type, proxy);
+ proxies[type] = undefined;
+ }
+ getDevicePixelRatio() {
+ return window.devicePixelRatio;
+ }
+ getMaximumSize(canvas, width, height, aspectRatio) {
+ return getMaximumSize(canvas, width, height, aspectRatio);
+ }
+ isAttached(canvas) {
+ const container = _getParentNode(canvas);
+ return !!(container && container.isConnected);
+ }
+}
+
+function _detectPlatform(canvas) {
+ if (!_isDomSupported() || (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas)) {
+ return BasicPlatform;
+ }
+ return DomPlatform;
+}
+
+var platforms = /*#__PURE__*/Object.freeze({
+__proto__: null,
+_detectPlatform: _detectPlatform,
+BasePlatform: BasePlatform,
+BasicPlatform: BasicPlatform,
+DomPlatform: DomPlatform
+});
+
+const transparent = 'transparent';
+const interpolators = {
+ boolean(from, to, factor) {
+ return factor > 0.5 ? to : from;
+ },
+ color(from, to, factor) {
+ const c0 = color(from || transparent);
+ const c1 = c0.valid && color(to || transparent);
+ return c1 && c1.valid
+ ? c1.mix(c0, factor).hexString()
+ : to;
+ },
+ number(from, to, factor) {
+ return from + (to - from) * factor;
+ }
+};
+class Animation {
+ constructor(cfg, target, prop, to) {
+ const currentValue = target[prop];
+ to = resolve([cfg.to, to, currentValue, cfg.from]);
+ const from = resolve([cfg.from, currentValue, to]);
+ this._active = true;
+ this._fn = cfg.fn || interpolators[cfg.type || typeof from];
+ this._easing = effects[cfg.easing] || effects.linear;
+ this._start = Math.floor(Date.now() + (cfg.delay || 0));
+ this._duration = this._total = Math.floor(cfg.duration);
+ this._loop = !!cfg.loop;
+ this._target = target;
+ this._prop = prop;
+ this._from = from;
+ this._to = to;
+ this._promises = undefined;
+ }
+ active() {
+ return this._active;
+ }
+ update(cfg, to, date) {
+ if (this._active) {
+ this._notify(false);
+ const currentValue = this._target[this._prop];
+ const elapsed = date - this._start;
+ const remain = this._duration - elapsed;
+ this._start = date;
+ this._duration = Math.floor(Math.max(remain, cfg.duration));
+ this._total += elapsed;
+ this._loop = !!cfg.loop;
+ this._to = resolve([cfg.to, to, currentValue, cfg.from]);
+ this._from = resolve([cfg.from, currentValue, to]);
+ }
+ }
+ cancel() {
+ if (this._active) {
+ this.tick(Date.now());
+ this._active = false;
+ this._notify(false);
+ }
+ }
+ tick(date) {
+ const elapsed = date - this._start;
+ const duration = this._duration;
+ const prop = this._prop;
+ const from = this._from;
+ const loop = this._loop;
+ const to = this._to;
+ let factor;
+ this._active = from !== to && (loop || (elapsed < duration));
+ if (!this._active) {
+ this._target[prop] = to;
+ this._notify(true);
+ return;
+ }
+ if (elapsed < 0) {
+ this._target[prop] = from;
+ return;
+ }
+ factor = (elapsed / duration) % 2;
+ factor = loop && factor > 1 ? 2 - factor : factor;
+ factor = this._easing(Math.min(1, Math.max(0, factor)));
+ this._target[prop] = this._fn(from, to, factor);
+ }
+ wait() {
+ const promises = this._promises || (this._promises = []);
+ return new Promise((res, rej) => {
+ promises.push({res, rej});
+ });
+ }
+ _notify(resolved) {
+ const method = resolved ? 'res' : 'rej';
+ const promises = this._promises || [];
+ for (let i = 0; i < promises.length; i++) {
+ promises[i][method]();
+ }
+ }
+}
+
+const numbers = ['x', 'y', 'borderWidth', 'radius', 'tension'];
+const colors = ['color', 'borderColor', 'backgroundColor'];
+defaults.set('animation', {
+ delay: undefined,
+ duration: 1000,
+ easing: 'easeOutQuart',
+ fn: undefined,
+ from: undefined,
+ loop: undefined,
+ to: undefined,
+ type: undefined,
+});
+const animationOptions = Object.keys(defaults.animation);
+defaults.describe('animation', {
+ _fallback: false,
+ _indexable: false,
+ _scriptable: (name) => name !== 'onProgress' && name !== 'onComplete' && name !== 'fn',
+});
+defaults.set('animations', {
+ colors: {
+ type: 'color',
+ properties: colors
+ },
+ numbers: {
+ type: 'number',
+ properties: numbers
+ },
+});
+defaults.describe('animations', {
+ _fallback: 'animation',
+});
+defaults.set('transitions', {
+ active: {
+ animation: {
+ duration: 400
+ }
+ },
+ resize: {
+ animation: {
+ duration: 0
+ }
+ },
+ show: {
+ animations: {
+ colors: {
+ from: 'transparent'
+ },
+ visible: {
+ type: 'boolean',
+ duration: 0
+ },
+ }
+ },
+ hide: {
+ animations: {
+ colors: {
+ to: 'transparent'
+ },
+ visible: {
+ type: 'boolean',
+ easing: 'linear',
+ fn: v => v | 0
+ },
+ }
+ }
+});
+class Animations {
+ constructor(chart, config) {
+ this._chart = chart;
+ this._properties = new Map();
+ this.configure(config);
+ }
+ configure(config) {
+ if (!isObject(config)) {
+ return;
+ }
+ const animatedProps = this._properties;
+ Object.getOwnPropertyNames(config).forEach(key => {
+ const cfg = config[key];
+ if (!isObject(cfg)) {
+ return;
+ }
+ const resolved = {};
+ for (const option of animationOptions) {
+ resolved[option] = cfg[option];
+ }
+ (isArray(cfg.properties) && cfg.properties || [key]).forEach((prop) => {
+ if (prop === key || !animatedProps.has(prop)) {
+ animatedProps.set(prop, resolved);
+ }
+ });
+ });
+ }
+ _animateOptions(target, values) {
+ const newOptions = values.options;
+ const options = resolveTargetOptions(target, newOptions);
+ if (!options) {
+ return [];
+ }
+ const animations = this._createAnimations(options, newOptions);
+ if (newOptions.$shared) {
+ awaitAll(target.options.$animations, newOptions).then(() => {
+ target.options = newOptions;
+ }, () => {
+ });
+ }
+ return animations;
+ }
+ _createAnimations(target, values) {
+ const animatedProps = this._properties;
+ const animations = [];
+ const running = target.$animations || (target.$animations = {});
+ const props = Object.keys(values);
+ const date = Date.now();
+ let i;
+ for (i = props.length - 1; i >= 0; --i) {
+ const prop = props[i];
+ if (prop.charAt(0) === '$') {
+ continue;
+ }
+ if (prop === 'options') {
+ animations.push(...this._animateOptions(target, values));
+ continue;
+ }
+ const value = values[prop];
+ let animation = running[prop];
+ const cfg = animatedProps.get(prop);
+ if (animation) {
+ if (cfg && animation.active()) {
+ animation.update(cfg, value, date);
+ continue;
+ } else {
+ animation.cancel();
+ }
+ }
+ if (!cfg || !cfg.duration) {
+ target[prop] = value;
+ continue;
+ }
+ running[prop] = animation = new Animation(cfg, target, prop, value);
+ animations.push(animation);
+ }
+ return animations;
+ }
+ update(target, values) {
+ if (this._properties.size === 0) {
+ Object.assign(target, values);
+ return;
+ }
+ const animations = this._createAnimations(target, values);
+ if (animations.length) {
+ animator.add(this._chart, animations);
+ return true;
+ }
+ }
+}
+function awaitAll(animations, properties) {
+ const running = [];
+ const keys = Object.keys(properties);
+ for (let i = 0; i < keys.length; i++) {
+ const anim = animations[keys[i]];
+ if (anim && anim.active()) {
+ running.push(anim.wait());
+ }
+ }
+ return Promise.all(running);
+}
+function resolveTargetOptions(target, newOptions) {
+ if (!newOptions) {
+ return;
+ }
+ let options = target.options;
+ if (!options) {
+ target.options = newOptions;
+ return;
+ }
+ if (options.$shared) {
+ target.options = options = Object.assign({}, options, {$shared: false, $animations: {}});
+ }
+ return options;
+}
+
+function scaleClip(scale, allowedOverflow) {
+ const opts = scale && scale.options || {};
+ const reverse = opts.reverse;
+ const min = opts.min === undefined ? allowedOverflow : 0;
+ const max = opts.max === undefined ? allowedOverflow : 0;
+ return {
+ start: reverse ? max : min,
+ end: reverse ? min : max
+ };
+}
+function defaultClip(xScale, yScale, allowedOverflow) {
+ if (allowedOverflow === false) {
+ return false;
+ }
+ const x = scaleClip(xScale, allowedOverflow);
+ const y = scaleClip(yScale, allowedOverflow);
+ return {
+ top: y.end,
+ right: x.end,
+ bottom: y.start,
+ left: x.start
+ };
+}
+function toClip(value) {
+ let t, r, b, l;
+ if (isObject(value)) {
+ t = value.top;
+ r = value.right;
+ b = value.bottom;
+ l = value.left;
+ } else {
+ t = r = b = l = value;
+ }
+ return {
+ top: t,
+ right: r,
+ bottom: b,
+ left: l,
+ disabled: value === false
+ };
+}
+function getSortedDatasetIndices(chart, filterVisible) {
+ const keys = [];
+ const metasets = chart._getSortedDatasetMetas(filterVisible);
+ let i, ilen;
+ for (i = 0, ilen = metasets.length; i < ilen; ++i) {
+ keys.push(metasets[i].index);
+ }
+ return keys;
+}
+function applyStack(stack, value, dsIndex, options = {}) {
+ const keys = stack.keys;
+ const singleMode = options.mode === 'single';
+ let i, ilen, datasetIndex, otherValue;
+ if (value === null) {
+ return;
+ }
+ for (i = 0, ilen = keys.length; i < ilen; ++i) {
+ datasetIndex = +keys[i];
+ if (datasetIndex === dsIndex) {
+ if (options.all) {
+ continue;
+ }
+ break;
+ }
+ otherValue = stack.values[datasetIndex];
+ if (isNumberFinite(otherValue) && (singleMode || (value === 0 || sign(value) === sign(otherValue)))) {
+ value += otherValue;
+ }
+ }
+ return value;
+}
+function convertObjectDataToArray(data) {
+ const keys = Object.keys(data);
+ const adata = new Array(keys.length);
+ let i, ilen, key;
+ for (i = 0, ilen = keys.length; i < ilen; ++i) {
+ key = keys[i];
+ adata[i] = {
+ x: key,
+ y: data[key]
+ };
+ }
+ return adata;
+}
+function isStacked(scale, meta) {
+ const stacked = scale && scale.options.stacked;
+ return stacked || (stacked === undefined && meta.stack !== undefined);
+}
+function getStackKey(indexScale, valueScale, meta) {
+ return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;
+}
+function getUserBounds(scale) {
+ const {min, max, minDefined, maxDefined} = scale.getUserBounds();
+ return {
+ min: minDefined ? min : Number.NEGATIVE_INFINITY,
+ max: maxDefined ? max : Number.POSITIVE_INFINITY
+ };
+}
+function getOrCreateStack(stacks, stackKey, indexValue) {
+ const subStack = stacks[stackKey] || (stacks[stackKey] = {});
+ return subStack[indexValue] || (subStack[indexValue] = {});
+}
+function getLastIndexInStack(stack, vScale, positive, type) {
+ for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) {
+ const value = stack[meta.index];
+ if ((positive && value > 0) || (!positive && value < 0)) {
+ return meta.index;
+ }
+ }
+ return null;
+}
+function updateStacks(controller, parsed) {
+ const {chart, _cachedMeta: meta} = controller;
+ const stacks = chart._stacks || (chart._stacks = {});
+ const {iScale, vScale, index: datasetIndex} = meta;
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ const key = getStackKey(iScale, vScale, meta);
+ const ilen = parsed.length;
+ let stack;
+ for (let i = 0; i < ilen; ++i) {
+ const item = parsed[i];
+ const {[iAxis]: index, [vAxis]: value} = item;
+ const itemStacks = item._stacks || (item._stacks = {});
+ stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);
+ stack[datasetIndex] = value;
+ stack._top = getLastIndexInStack(stack, vScale, true, meta.type);
+ stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);
+ }
+}
+function getFirstScaleId(chart, axis) {
+ const scales = chart.scales;
+ return Object.keys(scales).filter(key => scales[key].axis === axis).shift();
+}
+function createDatasetContext(parent, index) {
+ return createContext(parent,
+ {
+ active: false,
+ dataset: undefined,
+ datasetIndex: index,
+ index,
+ mode: 'default',
+ type: 'dataset'
+ }
+ );
+}
+function createDataContext(parent, index, element) {
+ return createContext(parent, {
+ active: false,
+ dataIndex: index,
+ parsed: undefined,
+ raw: undefined,
+ element,
+ index,
+ mode: 'default',
+ type: 'data'
+ });
+}
+function clearStacks(meta, items) {
+ const datasetIndex = meta.controller.index;
+ const axis = meta.vScale && meta.vScale.axis;
+ if (!axis) {
+ return;
+ }
+ items = items || meta._parsed;
+ for (const parsed of items) {
+ const stacks = parsed._stacks;
+ if (!stacks || stacks[axis] === undefined || stacks[axis][datasetIndex] === undefined) {
+ return;
+ }
+ delete stacks[axis][datasetIndex];
+ }
+}
+const isDirectUpdateMode = (mode) => mode === 'reset' || mode === 'none';
+const cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached);
+const createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked
+ && {keys: getSortedDatasetIndices(chart, true), values: null};
+class DatasetController {
+ constructor(chart, datasetIndex) {
+ this.chart = chart;
+ this._ctx = chart.ctx;
+ this.index = datasetIndex;
+ this._cachedDataOpts = {};
+ this._cachedMeta = this.getMeta();
+ this._type = this._cachedMeta.type;
+ this.options = undefined;
+ this._parsing = false;
+ this._data = undefined;
+ this._objectData = undefined;
+ this._sharedOptions = undefined;
+ this._drawStart = undefined;
+ this._drawCount = undefined;
+ this.enableOptionSharing = false;
+ this.$context = undefined;
+ this._syncList = [];
+ this.initialize();
+ }
+ initialize() {
+ const meta = this._cachedMeta;
+ this.configure();
+ this.linkScales();
+ meta._stacked = isStacked(meta.vScale, meta);
+ this.addElements();
+ }
+ updateIndex(datasetIndex) {
+ if (this.index !== datasetIndex) {
+ clearStacks(this._cachedMeta);
+ }
+ this.index = datasetIndex;
+ }
+ linkScales() {
+ const chart = this.chart;
+ const meta = this._cachedMeta;
+ const dataset = this.getDataset();
+ const chooseId = (axis, x, y, r) => axis === 'x' ? x : axis === 'r' ? r : y;
+ const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x'));
+ const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y'));
+ const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r'));
+ const indexAxis = meta.indexAxis;
+ const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);
+ const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);
+ meta.xScale = this.getScaleForId(xid);
+ meta.yScale = this.getScaleForId(yid);
+ meta.rScale = this.getScaleForId(rid);
+ meta.iScale = this.getScaleForId(iid);
+ meta.vScale = this.getScaleForId(vid);
+ }
+ getDataset() {
+ return this.chart.data.datasets[this.index];
+ }
+ getMeta() {
+ return this.chart.getDatasetMeta(this.index);
+ }
+ getScaleForId(scaleID) {
+ return this.chart.scales[scaleID];
+ }
+ _getOtherScale(scale) {
+ const meta = this._cachedMeta;
+ return scale === meta.iScale
+ ? meta.vScale
+ : meta.iScale;
+ }
+ reset() {
+ this._update('reset');
+ }
+ _destroy() {
+ const meta = this._cachedMeta;
+ if (this._data) {
+ unlistenArrayEvents(this._data, this);
+ }
+ if (meta._stacked) {
+ clearStacks(meta);
+ }
+ }
+ _dataCheck() {
+ const dataset = this.getDataset();
+ const data = dataset.data || (dataset.data = []);
+ const _data = this._data;
+ if (isObject(data)) {
+ this._data = convertObjectDataToArray(data);
+ } else if (_data !== data) {
+ if (_data) {
+ unlistenArrayEvents(_data, this);
+ const meta = this._cachedMeta;
+ clearStacks(meta);
+ meta._parsed = [];
+ }
+ if (data && Object.isExtensible(data)) {
+ listenArrayEvents(data, this);
+ }
+ this._syncList = [];
+ this._data = data;
+ }
+ }
+ addElements() {
+ const meta = this._cachedMeta;
+ this._dataCheck();
+ if (this.datasetElementType) {
+ meta.dataset = new this.datasetElementType();
+ }
+ }
+ buildOrUpdateElements(resetNewElements) {
+ const meta = this._cachedMeta;
+ const dataset = this.getDataset();
+ let stackChanged = false;
+ this._dataCheck();
+ const oldStacked = meta._stacked;
+ meta._stacked = isStacked(meta.vScale, meta);
+ if (meta.stack !== dataset.stack) {
+ stackChanged = true;
+ clearStacks(meta);
+ meta.stack = dataset.stack;
+ }
+ this._resyncElements(resetNewElements);
+ if (stackChanged || oldStacked !== meta._stacked) {
+ updateStacks(this, meta._parsed);
+ }
+ }
+ configure() {
+ const config = this.chart.config;
+ const scopeKeys = config.datasetScopeKeys(this._type);
+ const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);
+ this.options = config.createResolver(scopes, this.getContext());
+ this._parsing = this.options.parsing;
+ this._cachedDataOpts = {};
+ }
+ parse(start, count) {
+ const {_cachedMeta: meta, _data: data} = this;
+ const {iScale, _stacked} = meta;
+ const iAxis = iScale.axis;
+ let sorted = start === 0 && count === data.length ? true : meta._sorted;
+ let prev = start > 0 && meta._parsed[start - 1];
+ let i, cur, parsed;
+ if (this._parsing === false) {
+ meta._parsed = data;
+ meta._sorted = true;
+ parsed = data;
+ } else {
+ if (isArray(data[start])) {
+ parsed = this.parseArrayData(meta, data, start, count);
+ } else if (isObject(data[start])) {
+ parsed = this.parseObjectData(meta, data, start, count);
+ } else {
+ parsed = this.parsePrimitiveData(meta, data, start, count);
+ }
+ const isNotInOrderComparedToPrev = () => cur[iAxis] === null || (prev && cur[iAxis] < prev[iAxis]);
+ for (i = 0; i < count; ++i) {
+ meta._parsed[i + start] = cur = parsed[i];
+ if (sorted) {
+ if (isNotInOrderComparedToPrev()) {
+ sorted = false;
+ }
+ prev = cur;
+ }
+ }
+ meta._sorted = sorted;
+ }
+ if (_stacked) {
+ updateStacks(this, parsed);
+ }
+ }
+ parsePrimitiveData(meta, data, start, count) {
+ const {iScale, vScale} = meta;
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ const labels = iScale.getLabels();
+ const singleScale = iScale === vScale;
+ const parsed = new Array(count);
+ let i, ilen, index;
+ for (i = 0, ilen = count; i < ilen; ++i) {
+ index = i + start;
+ parsed[i] = {
+ [iAxis]: singleScale || iScale.parse(labels[index], index),
+ [vAxis]: vScale.parse(data[index], index)
+ };
+ }
+ return parsed;
+ }
+ parseArrayData(meta, data, start, count) {
+ const {xScale, yScale} = meta;
+ const parsed = new Array(count);
+ let i, ilen, index, item;
+ for (i = 0, ilen = count; i < ilen; ++i) {
+ index = i + start;
+ item = data[index];
+ parsed[i] = {
+ x: xScale.parse(item[0], index),
+ y: yScale.parse(item[1], index)
+ };
+ }
+ return parsed;
+ }
+ parseObjectData(meta, data, start, count) {
+ const {xScale, yScale} = meta;
+ const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;
+ const parsed = new Array(count);
+ let i, ilen, index, item;
+ for (i = 0, ilen = count; i < ilen; ++i) {
+ index = i + start;
+ item = data[index];
+ parsed[i] = {
+ x: xScale.parse(resolveObjectKey(item, xAxisKey), index),
+ y: yScale.parse(resolveObjectKey(item, yAxisKey), index)
+ };
+ }
+ return parsed;
+ }
+ getParsed(index) {
+ return this._cachedMeta._parsed[index];
+ }
+ getDataElement(index) {
+ return this._cachedMeta.data[index];
+ }
+ applyStack(scale, parsed, mode) {
+ const chart = this.chart;
+ const meta = this._cachedMeta;
+ const value = parsed[scale.axis];
+ const stack = {
+ keys: getSortedDatasetIndices(chart, true),
+ values: parsed._stacks[scale.axis]
+ };
+ return applyStack(stack, value, meta.index, {mode});
+ }
+ updateRangeFromParsed(range, scale, parsed, stack) {
+ const parsedValue = parsed[scale.axis];
+ let value = parsedValue === null ? NaN : parsedValue;
+ const values = stack && parsed._stacks[scale.axis];
+ if (stack && values) {
+ stack.values = values;
+ value = applyStack(stack, parsedValue, this._cachedMeta.index);
+ }
+ range.min = Math.min(range.min, value);
+ range.max = Math.max(range.max, value);
+ }
+ getMinMax(scale, canStack) {
+ const meta = this._cachedMeta;
+ const _parsed = meta._parsed;
+ const sorted = meta._sorted && scale === meta.iScale;
+ const ilen = _parsed.length;
+ const otherScale = this._getOtherScale(scale);
+ const stack = createStack(canStack, meta, this.chart);
+ const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY};
+ const {min: otherMin, max: otherMax} = getUserBounds(otherScale);
+ let i, parsed;
+ function _skip() {
+ parsed = _parsed[i];
+ const otherValue = parsed[otherScale.axis];
+ return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;
+ }
+ for (i = 0; i < ilen; ++i) {
+ if (_skip()) {
+ continue;
+ }
+ this.updateRangeFromParsed(range, scale, parsed, stack);
+ if (sorted) {
+ break;
+ }
+ }
+ if (sorted) {
+ for (i = ilen - 1; i >= 0; --i) {
+ if (_skip()) {
+ continue;
+ }
+ this.updateRangeFromParsed(range, scale, parsed, stack);
+ break;
+ }
+ }
+ return range;
+ }
+ getAllParsedValues(scale) {
+ const parsed = this._cachedMeta._parsed;
+ const values = [];
+ let i, ilen, value;
+ for (i = 0, ilen = parsed.length; i < ilen; ++i) {
+ value = parsed[i][scale.axis];
+ if (isNumberFinite(value)) {
+ values.push(value);
+ }
+ }
+ return values;
+ }
+ getMaxOverflow() {
+ return false;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const iScale = meta.iScale;
+ const vScale = meta.vScale;
+ const parsed = this.getParsed(index);
+ return {
+ label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '',
+ value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : ''
+ };
+ }
+ _update(mode) {
+ const meta = this._cachedMeta;
+ this.update(mode || 'default');
+ meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));
+ }
+ update(mode) {}
+ draw() {
+ const ctx = this._ctx;
+ const chart = this.chart;
+ const meta = this._cachedMeta;
+ const elements = meta.data || [];
+ const area = chart.chartArea;
+ const active = [];
+ const start = this._drawStart || 0;
+ const count = this._drawCount || (elements.length - start);
+ const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;
+ let i;
+ if (meta.dataset) {
+ meta.dataset.draw(ctx, area, start, count);
+ }
+ for (i = start; i < start + count; ++i) {
+ const element = elements[i];
+ if (element.hidden) {
+ continue;
+ }
+ if (element.active && drawActiveElementsOnTop) {
+ active.push(element);
+ } else {
+ element.draw(ctx, area);
+ }
+ }
+ for (i = 0; i < active.length; ++i) {
+ active[i].draw(ctx, area);
+ }
+ }
+ getStyle(index, active) {
+ const mode = active ? 'active' : 'default';
+ return index === undefined && this._cachedMeta.dataset
+ ? this.resolveDatasetElementOptions(mode)
+ : this.resolveDataElementOptions(index || 0, mode);
+ }
+ getContext(index, active, mode) {
+ const dataset = this.getDataset();
+ let context;
+ if (index >= 0 && index < this._cachedMeta.data.length) {
+ const element = this._cachedMeta.data[index];
+ context = element.$context ||
+ (element.$context = createDataContext(this.getContext(), index, element));
+ context.parsed = this.getParsed(index);
+ context.raw = dataset.data[index];
+ context.index = context.dataIndex = index;
+ } else {
+ context = this.$context ||
+ (this.$context = createDatasetContext(this.chart.getContext(), this.index));
+ context.dataset = dataset;
+ context.index = context.datasetIndex = this.index;
+ }
+ context.active = !!active;
+ context.mode = mode;
+ return context;
+ }
+ resolveDatasetElementOptions(mode) {
+ return this._resolveElementOptions(this.datasetElementType.id, mode);
+ }
+ resolveDataElementOptions(index, mode) {
+ return this._resolveElementOptions(this.dataElementType.id, mode, index);
+ }
+ _resolveElementOptions(elementType, mode = 'default', index) {
+ const active = mode === 'active';
+ const cache = this._cachedDataOpts;
+ const cacheKey = elementType + '-' + mode;
+ const cached = cache[cacheKey];
+ const sharing = this.enableOptionSharing && defined(index);
+ if (cached) {
+ return cloneIfNotShared(cached, sharing);
+ }
+ const config = this.chart.config;
+ const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);
+ const prefixes = active ? [`${elementType}Hover`, 'hover', elementType, ''] : [elementType, ''];
+ const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
+ const names = Object.keys(defaults.elements[elementType]);
+ const context = () => this.getContext(index, active);
+ const values = config.resolveNamedOptions(scopes, names, context, prefixes);
+ if (values.$shared) {
+ values.$shared = sharing;
+ cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));
+ }
+ return values;
+ }
+ _resolveAnimations(index, transition, active) {
+ const chart = this.chart;
+ const cache = this._cachedDataOpts;
+ const cacheKey = `animation-${transition}`;
+ const cached = cache[cacheKey];
+ if (cached) {
+ return cached;
+ }
+ let options;
+ if (chart.options.animation !== false) {
+ const config = this.chart.config;
+ const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);
+ const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);
+ options = config.createResolver(scopes, this.getContext(index, active, transition));
+ }
+ const animations = new Animations(chart, options && options.animations);
+ if (options && options._cacheable) {
+ cache[cacheKey] = Object.freeze(animations);
+ }
+ return animations;
+ }
+ getSharedOptions(options) {
+ if (!options.$shared) {
+ return;
+ }
+ return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));
+ }
+ includeOptions(mode, sharedOptions) {
+ return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;
+ }
+ updateElement(element, index, properties, mode) {
+ if (isDirectUpdateMode(mode)) {
+ Object.assign(element, properties);
+ } else {
+ this._resolveAnimations(index, mode).update(element, properties);
+ }
+ }
+ updateSharedOptions(sharedOptions, mode, newOptions) {
+ if (sharedOptions && !isDirectUpdateMode(mode)) {
+ this._resolveAnimations(undefined, mode).update(sharedOptions, newOptions);
+ }
+ }
+ _setStyle(element, index, mode, active) {
+ element.active = active;
+ const options = this.getStyle(index, active);
+ this._resolveAnimations(index, mode, active).update(element, {
+ options: (!active && this.getSharedOptions(options)) || options
+ });
+ }
+ removeHoverStyle(element, datasetIndex, index) {
+ this._setStyle(element, index, 'active', false);
+ }
+ setHoverStyle(element, datasetIndex, index) {
+ this._setStyle(element, index, 'active', true);
+ }
+ _removeDatasetHoverStyle() {
+ const element = this._cachedMeta.dataset;
+ if (element) {
+ this._setStyle(element, undefined, 'active', false);
+ }
+ }
+ _setDatasetHoverStyle() {
+ const element = this._cachedMeta.dataset;
+ if (element) {
+ this._setStyle(element, undefined, 'active', true);
+ }
+ }
+ _resyncElements(resetNewElements) {
+ const data = this._data;
+ const elements = this._cachedMeta.data;
+ for (const [method, arg1, arg2] of this._syncList) {
+ this[method](arg1, arg2);
+ }
+ this._syncList = [];
+ const numMeta = elements.length;
+ const numData = data.length;
+ const count = Math.min(numData, numMeta);
+ if (count) {
+ this.parse(0, count);
+ }
+ if (numData > numMeta) {
+ this._insertElements(numMeta, numData - numMeta, resetNewElements);
+ } else if (numData < numMeta) {
+ this._removeElements(numData, numMeta - numData);
+ }
+ }
+ _insertElements(start, count, resetNewElements = true) {
+ const meta = this._cachedMeta;
+ const data = meta.data;
+ const end = start + count;
+ let i;
+ const move = (arr) => {
+ arr.length += count;
+ for (i = arr.length - 1; i >= end; i--) {
+ arr[i] = arr[i - count];
+ }
+ };
+ move(data);
+ for (i = start; i < end; ++i) {
+ data[i] = new this.dataElementType();
+ }
+ if (this._parsing) {
+ move(meta._parsed);
+ }
+ this.parse(start, count);
+ if (resetNewElements) {
+ this.updateElements(data, start, count, 'reset');
+ }
+ }
+ updateElements(element, start, count, mode) {}
+ _removeElements(start, count) {
+ const meta = this._cachedMeta;
+ if (this._parsing) {
+ const removed = meta._parsed.splice(start, count);
+ if (meta._stacked) {
+ clearStacks(meta, removed);
+ }
+ }
+ meta.data.splice(start, count);
+ }
+ _sync(args) {
+ if (this._parsing) {
+ this._syncList.push(args);
+ } else {
+ const [method, arg1, arg2] = args;
+ this[method](arg1, arg2);
+ }
+ this.chart._dataChanges.push([this.index, ...args]);
+ }
+ _onDataPush() {
+ const count = arguments.length;
+ this._sync(['_insertElements', this.getDataset().data.length - count, count]);
+ }
+ _onDataPop() {
+ this._sync(['_removeElements', this._cachedMeta.data.length - 1, 1]);
+ }
+ _onDataShift() {
+ this._sync(['_removeElements', 0, 1]);
+ }
+ _onDataSplice(start, count) {
+ if (count) {
+ this._sync(['_removeElements', start, count]);
+ }
+ const newCount = arguments.length - 2;
+ if (newCount) {
+ this._sync(['_insertElements', start, newCount]);
+ }
+ }
+ _onDataUnshift() {
+ this._sync(['_insertElements', 0, arguments.length]);
+ }
+}
+DatasetController.defaults = {};
+DatasetController.prototype.datasetElementType = null;
+DatasetController.prototype.dataElementType = null;
+
+class Element {
+ constructor() {
+ this.x = undefined;
+ this.y = undefined;
+ this.active = false;
+ this.options = undefined;
+ this.$animations = undefined;
+ }
+ tooltipPosition(useFinalPosition) {
+ const {x, y} = this.getProps(['x', 'y'], useFinalPosition);
+ return {x, y};
+ }
+ hasValue() {
+ return isNumber(this.x) && isNumber(this.y);
+ }
+ getProps(props, final) {
+ const anims = this.$animations;
+ if (!final || !anims) {
+ return this;
+ }
+ const ret = {};
+ props.forEach(prop => {
+ ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop];
+ });
+ return ret;
+ }
+}
+Element.defaults = {};
+Element.defaultRoutes = undefined;
+
+const formatters = {
+ values(value) {
+ return isArray(value) ? value : '' + value;
+ },
+ numeric(tickValue, index, ticks) {
+ if (tickValue === 0) {
+ return '0';
+ }
+ const locale = this.chart.options.locale;
+ let notation;
+ let delta = tickValue;
+ if (ticks.length > 1) {
+ const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));
+ if (maxTick < 1e-4 || maxTick > 1e+15) {
+ notation = 'scientific';
+ }
+ delta = calculateDelta(tickValue, ticks);
+ }
+ const logDelta = log10(Math.abs(delta));
+ const numDecimal = Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);
+ const options = {notation, minimumFractionDigits: numDecimal, maximumFractionDigits: numDecimal};
+ Object.assign(options, this.options.ticks.format);
+ return formatNumber(tickValue, locale, options);
+ },
+ logarithmic(tickValue, index, ticks) {
+ if (tickValue === 0) {
+ return '0';
+ }
+ const remain = tickValue / (Math.pow(10, Math.floor(log10(tickValue))));
+ if (remain === 1 || remain === 2 || remain === 5) {
+ return formatters.numeric.call(this, tickValue, index, ticks);
+ }
+ return '';
+ }
+};
+function calculateDelta(tickValue, ticks) {
+ let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;
+ if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {
+ delta = tickValue - Math.floor(tickValue);
+ }
+ return delta;
+}
+var Ticks = {formatters};
+
+defaults.set('scale', {
+ display: true,
+ offset: false,
+ reverse: false,
+ beginAtZero: false,
+ bounds: 'ticks',
+ grace: 0,
+ grid: {
+ display: true,
+ lineWidth: 1,
+ drawBorder: true,
+ drawOnChartArea: true,
+ drawTicks: true,
+ tickLength: 8,
+ tickWidth: (_ctx, options) => options.lineWidth,
+ tickColor: (_ctx, options) => options.color,
+ offset: false,
+ borderDash: [],
+ borderDashOffset: 0.0,
+ borderWidth: 1
+ },
+ title: {
+ display: false,
+ text: '',
+ padding: {
+ top: 4,
+ bottom: 4
+ }
+ },
+ ticks: {
+ minRotation: 0,
+ maxRotation: 50,
+ mirror: false,
+ textStrokeWidth: 0,
+ textStrokeColor: '',
+ padding: 3,
+ display: true,
+ autoSkip: true,
+ autoSkipPadding: 3,
+ labelOffset: 0,
+ callback: Ticks.formatters.values,
+ minor: {},
+ major: {},
+ align: 'center',
+ crossAlign: 'near',
+ showLabelBackdrop: false,
+ backdropColor: 'rgba(255, 255, 255, 0.75)',
+ backdropPadding: 2,
+ }
+});
+defaults.route('scale.ticks', 'color', '', 'color');
+defaults.route('scale.grid', 'color', '', 'borderColor');
+defaults.route('scale.grid', 'borderColor', '', 'borderColor');
+defaults.route('scale.title', 'color', '', 'color');
+defaults.describe('scale', {
+ _fallback: false,
+ _scriptable: (name) => !name.startsWith('before') && !name.startsWith('after') && name !== 'callback' && name !== 'parser',
+ _indexable: (name) => name !== 'borderDash' && name !== 'tickBorderDash',
+});
+defaults.describe('scales', {
+ _fallback: 'scale',
+});
+defaults.describe('scale.ticks', {
+ _scriptable: (name) => name !== 'backdropPadding' && name !== 'callback',
+ _indexable: (name) => name !== 'backdropPadding',
+});
+
+function autoSkip(scale, ticks) {
+ const tickOpts = scale.options.ticks;
+ const ticksLimit = tickOpts.maxTicksLimit || determineMaxTicks(scale);
+ const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];
+ const numMajorIndices = majorIndices.length;
+ const first = majorIndices[0];
+ const last = majorIndices[numMajorIndices - 1];
+ const newTicks = [];
+ if (numMajorIndices > ticksLimit) {
+ skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);
+ return newTicks;
+ }
+ const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);
+ if (numMajorIndices > 0) {
+ let i, ilen;
+ const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;
+ skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);
+ for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) {
+ skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]);
+ }
+ skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);
+ return newTicks;
+ }
+ skip(ticks, newTicks, spacing);
+ return newTicks;
+}
+function determineMaxTicks(scale) {
+ const offset = scale.options.offset;
+ const tickLength = scale._tickSize();
+ const maxScale = scale._length / tickLength + (offset ? 0 : 1);
+ const maxChart = scale._maxLength / tickLength;
+ return Math.floor(Math.min(maxScale, maxChart));
+}
+function calculateSpacing(majorIndices, ticks, ticksLimit) {
+ const evenMajorSpacing = getEvenSpacing(majorIndices);
+ const spacing = ticks.length / ticksLimit;
+ if (!evenMajorSpacing) {
+ return Math.max(spacing, 1);
+ }
+ const factors = _factorize(evenMajorSpacing);
+ for (let i = 0, ilen = factors.length - 1; i < ilen; i++) {
+ const factor = factors[i];
+ if (factor > spacing) {
+ return factor;
+ }
+ }
+ return Math.max(spacing, 1);
+}
+function getMajorIndices(ticks) {
+ const result = [];
+ let i, ilen;
+ for (i = 0, ilen = ticks.length; i < ilen; i++) {
+ if (ticks[i].major) {
+ result.push(i);
+ }
+ }
+ return result;
+}
+function skipMajors(ticks, newTicks, majorIndices, spacing) {
+ let count = 0;
+ let next = majorIndices[0];
+ let i;
+ spacing = Math.ceil(spacing);
+ for (i = 0; i < ticks.length; i++) {
+ if (i === next) {
+ newTicks.push(ticks[i]);
+ count++;
+ next = majorIndices[count * spacing];
+ }
+ }
+}
+function skip(ticks, newTicks, spacing, majorStart, majorEnd) {
+ const start = valueOrDefault(majorStart, 0);
+ const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);
+ let count = 0;
+ let length, i, next;
+ spacing = Math.ceil(spacing);
+ if (majorEnd) {
+ length = majorEnd - majorStart;
+ spacing = length / Math.floor(length / spacing);
+ }
+ next = start;
+ while (next < 0) {
+ count++;
+ next = Math.round(start + count * spacing);
+ }
+ for (i = Math.max(start, 0); i < end; i++) {
+ if (i === next) {
+ newTicks.push(ticks[i]);
+ count++;
+ next = Math.round(start + count * spacing);
+ }
+ }
+}
+function getEvenSpacing(arr) {
+ const len = arr.length;
+ let i, diff;
+ if (len < 2) {
+ return false;
+ }
+ for (diff = arr[0], i = 1; i < len; ++i) {
+ if (arr[i] - arr[i - 1] !== diff) {
+ return false;
+ }
+ }
+ return diff;
+}
+
+const reverseAlign = (align) => align === 'left' ? 'right' : align === 'right' ? 'left' : align;
+const offsetFromEdge = (scale, edge, offset) => edge === 'top' || edge === 'left' ? scale[edge] + offset : scale[edge] - offset;
+function sample(arr, numItems) {
+ const result = [];
+ const increment = arr.length / numItems;
+ const len = arr.length;
+ let i = 0;
+ for (; i < len; i += increment) {
+ result.push(arr[Math.floor(i)]);
+ }
+ return result;
+}
+function getPixelForGridLine(scale, index, offsetGridLines) {
+ const length = scale.ticks.length;
+ const validIndex = Math.min(index, length - 1);
+ const start = scale._startPixel;
+ const end = scale._endPixel;
+ const epsilon = 1e-6;
+ let lineValue = scale.getPixelForTick(validIndex);
+ let offset;
+ if (offsetGridLines) {
+ if (length === 1) {
+ offset = Math.max(lineValue - start, end - lineValue);
+ } else if (index === 0) {
+ offset = (scale.getPixelForTick(1) - lineValue) / 2;
+ } else {
+ offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2;
+ }
+ lineValue += validIndex < index ? offset : -offset;
+ if (lineValue < start - epsilon || lineValue > end + epsilon) {
+ return;
+ }
+ }
+ return lineValue;
+}
+function garbageCollect(caches, length) {
+ each(caches, (cache) => {
+ const gc = cache.gc;
+ const gcLen = gc.length / 2;
+ let i;
+ if (gcLen > length) {
+ for (i = 0; i < gcLen; ++i) {
+ delete cache.data[gc[i]];
+ }
+ gc.splice(0, gcLen);
+ }
+ });
+}
+function getTickMarkLength(options) {
+ return options.drawTicks ? options.tickLength : 0;
+}
+function getTitleHeight(options, fallback) {
+ if (!options.display) {
+ return 0;
+ }
+ const font = toFont(options.font, fallback);
+ const padding = toPadding(options.padding);
+ const lines = isArray(options.text) ? options.text.length : 1;
+ return (lines * font.lineHeight) + padding.height;
+}
+function createScaleContext(parent, scale) {
+ return createContext(parent, {
+ scale,
+ type: 'scale'
+ });
+}
+function createTickContext(parent, index, tick) {
+ return createContext(parent, {
+ tick,
+ index,
+ type: 'tick'
+ });
+}
+function titleAlign(align, position, reverse) {
+ let ret = _toLeftRightCenter(align);
+ if ((reverse && position !== 'right') || (!reverse && position === 'right')) {
+ ret = reverseAlign(ret);
+ }
+ return ret;
+}
+function titleArgs(scale, offset, position, align) {
+ const {top, left, bottom, right, chart} = scale;
+ const {chartArea, scales} = chart;
+ let rotation = 0;
+ let maxWidth, titleX, titleY;
+ const height = bottom - top;
+ const width = right - left;
+ if (scale.isHorizontal()) {
+ titleX = _alignStartEnd(align, left, right);
+ if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;
+ } else if (position === 'center') {
+ titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;
+ } else {
+ titleY = offsetFromEdge(scale, position, offset);
+ }
+ maxWidth = right - left;
+ } else {
+ if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;
+ } else if (position === 'center') {
+ titleX = (chartArea.left + chartArea.right) / 2 - width + offset;
+ } else {
+ titleX = offsetFromEdge(scale, position, offset);
+ }
+ titleY = _alignStartEnd(align, bottom, top);
+ rotation = position === 'left' ? -HALF_PI : HALF_PI;
+ }
+ return {titleX, titleY, maxWidth, rotation};
+}
+class Scale extends Element {
+ constructor(cfg) {
+ super();
+ this.id = cfg.id;
+ this.type = cfg.type;
+ this.options = undefined;
+ this.ctx = cfg.ctx;
+ this.chart = cfg.chart;
+ this.top = undefined;
+ this.bottom = undefined;
+ this.left = undefined;
+ this.right = undefined;
+ this.width = undefined;
+ this.height = undefined;
+ this._margins = {
+ left: 0,
+ right: 0,
+ top: 0,
+ bottom: 0
+ };
+ this.maxWidth = undefined;
+ this.maxHeight = undefined;
+ this.paddingTop = undefined;
+ this.paddingBottom = undefined;
+ this.paddingLeft = undefined;
+ this.paddingRight = undefined;
+ this.axis = undefined;
+ this.labelRotation = undefined;
+ this.min = undefined;
+ this.max = undefined;
+ this._range = undefined;
+ this.ticks = [];
+ this._gridLineItems = null;
+ this._labelItems = null;
+ this._labelSizes = null;
+ this._length = 0;
+ this._maxLength = 0;
+ this._longestTextCache = {};
+ this._startPixel = undefined;
+ this._endPixel = undefined;
+ this._reversePixels = false;
+ this._userMax = undefined;
+ this._userMin = undefined;
+ this._suggestedMax = undefined;
+ this._suggestedMin = undefined;
+ this._ticksLength = 0;
+ this._borderValue = 0;
+ this._cache = {};
+ this._dataLimitsCached = false;
+ this.$context = undefined;
+ }
+ init(options) {
+ this.options = options.setContext(this.getContext());
+ this.axis = options.axis;
+ this._userMin = this.parse(options.min);
+ this._userMax = this.parse(options.max);
+ this._suggestedMin = this.parse(options.suggestedMin);
+ this._suggestedMax = this.parse(options.suggestedMax);
+ }
+ parse(raw, index) {
+ return raw;
+ }
+ getUserBounds() {
+ let {_userMin, _userMax, _suggestedMin, _suggestedMax} = this;
+ _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);
+ _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);
+ _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);
+ _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);
+ return {
+ min: finiteOrDefault(_userMin, _suggestedMin),
+ max: finiteOrDefault(_userMax, _suggestedMax),
+ minDefined: isNumberFinite(_userMin),
+ maxDefined: isNumberFinite(_userMax)
+ };
+ }
+ getMinMax(canStack) {
+ let {min, max, minDefined, maxDefined} = this.getUserBounds();
+ let range;
+ if (minDefined && maxDefined) {
+ return {min, max};
+ }
+ const metas = this.getMatchingVisibleMetas();
+ for (let i = 0, ilen = metas.length; i < ilen; ++i) {
+ range = metas[i].controller.getMinMax(this, canStack);
+ if (!minDefined) {
+ min = Math.min(min, range.min);
+ }
+ if (!maxDefined) {
+ max = Math.max(max, range.max);
+ }
+ }
+ min = maxDefined && min > max ? max : min;
+ max = minDefined && min > max ? min : max;
+ return {
+ min: finiteOrDefault(min, finiteOrDefault(max, min)),
+ max: finiteOrDefault(max, finiteOrDefault(min, max))
+ };
+ }
+ getPadding() {
+ return {
+ left: this.paddingLeft || 0,
+ top: this.paddingTop || 0,
+ right: this.paddingRight || 0,
+ bottom: this.paddingBottom || 0
+ };
+ }
+ getTicks() {
+ return this.ticks;
+ }
+ getLabels() {
+ const data = this.chart.data;
+ return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];
+ }
+ beforeLayout() {
+ this._cache = {};
+ this._dataLimitsCached = false;
+ }
+ beforeUpdate() {
+ callback(this.options.beforeUpdate, [this]);
+ }
+ update(maxWidth, maxHeight, margins) {
+ const {beginAtZero, grace, ticks: tickOpts} = this.options;
+ const sampleSize = tickOpts.sampleSize;
+ this.beforeUpdate();
+ this.maxWidth = maxWidth;
+ this.maxHeight = maxHeight;
+ this._margins = margins = Object.assign({
+ left: 0,
+ right: 0,
+ top: 0,
+ bottom: 0
+ }, margins);
+ this.ticks = null;
+ this._labelSizes = null;
+ this._gridLineItems = null;
+ this._labelItems = null;
+ this.beforeSetDimensions();
+ this.setDimensions();
+ this.afterSetDimensions();
+ this._maxLength = this.isHorizontal()
+ ? this.width + margins.left + margins.right
+ : this.height + margins.top + margins.bottom;
+ if (!this._dataLimitsCached) {
+ this.beforeDataLimits();
+ this.determineDataLimits();
+ this.afterDataLimits();
+ this._range = _addGrace(this, grace, beginAtZero);
+ this._dataLimitsCached = true;
+ }
+ this.beforeBuildTicks();
+ this.ticks = this.buildTicks() || [];
+ this.afterBuildTicks();
+ const samplingEnabled = sampleSize < this.ticks.length;
+ this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);
+ this.configure();
+ this.beforeCalculateLabelRotation();
+ this.calculateLabelRotation();
+ this.afterCalculateLabelRotation();
+ if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto')) {
+ this.ticks = autoSkip(this, this.ticks);
+ this._labelSizes = null;
+ }
+ if (samplingEnabled) {
+ this._convertTicksToLabels(this.ticks);
+ }
+ this.beforeFit();
+ this.fit();
+ this.afterFit();
+ this.afterUpdate();
+ }
+ configure() {
+ let reversePixels = this.options.reverse;
+ let startPixel, endPixel;
+ if (this.isHorizontal()) {
+ startPixel = this.left;
+ endPixel = this.right;
+ } else {
+ startPixel = this.top;
+ endPixel = this.bottom;
+ reversePixels = !reversePixels;
+ }
+ this._startPixel = startPixel;
+ this._endPixel = endPixel;
+ this._reversePixels = reversePixels;
+ this._length = endPixel - startPixel;
+ this._alignToPixels = this.options.alignToPixels;
+ }
+ afterUpdate() {
+ callback(this.options.afterUpdate, [this]);
+ }
+ beforeSetDimensions() {
+ callback(this.options.beforeSetDimensions, [this]);
+ }
+ setDimensions() {
+ if (this.isHorizontal()) {
+ this.width = this.maxWidth;
+ this.left = 0;
+ this.right = this.width;
+ } else {
+ this.height = this.maxHeight;
+ this.top = 0;
+ this.bottom = this.height;
+ }
+ this.paddingLeft = 0;
+ this.paddingTop = 0;
+ this.paddingRight = 0;
+ this.paddingBottom = 0;
+ }
+ afterSetDimensions() {
+ callback(this.options.afterSetDimensions, [this]);
+ }
+ _callHooks(name) {
+ this.chart.notifyPlugins(name, this.getContext());
+ callback(this.options[name], [this]);
+ }
+ beforeDataLimits() {
+ this._callHooks('beforeDataLimits');
+ }
+ determineDataLimits() {}
+ afterDataLimits() {
+ this._callHooks('afterDataLimits');
+ }
+ beforeBuildTicks() {
+ this._callHooks('beforeBuildTicks');
+ }
+ buildTicks() {
+ return [];
+ }
+ afterBuildTicks() {
+ this._callHooks('afterBuildTicks');
+ }
+ beforeTickToLabelConversion() {
+ callback(this.options.beforeTickToLabelConversion, [this]);
+ }
+ generateTickLabels(ticks) {
+ const tickOpts = this.options.ticks;
+ let i, ilen, tick;
+ for (i = 0, ilen = ticks.length; i < ilen; i++) {
+ tick = ticks[i];
+ tick.label = callback(tickOpts.callback, [tick.value, i, ticks], this);
+ }
+ }
+ afterTickToLabelConversion() {
+ callback(this.options.afterTickToLabelConversion, [this]);
+ }
+ beforeCalculateLabelRotation() {
+ callback(this.options.beforeCalculateLabelRotation, [this]);
+ }
+ calculateLabelRotation() {
+ const options = this.options;
+ const tickOpts = options.ticks;
+ const numTicks = this.ticks.length;
+ const minRotation = tickOpts.minRotation || 0;
+ const maxRotation = tickOpts.maxRotation;
+ let labelRotation = minRotation;
+ let tickWidth, maxHeight, maxLabelDiagonal;
+ if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {
+ this.labelRotation = minRotation;
+ return;
+ }
+ const labelSizes = this._getLabelSizes();
+ const maxLabelWidth = labelSizes.widest.width;
+ const maxLabelHeight = labelSizes.highest.height;
+ const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);
+ tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);
+ if (maxLabelWidth + 6 > tickWidth) {
+ tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));
+ maxHeight = this.maxHeight - getTickMarkLength(options.grid)
+ - tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);
+ maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);
+ labelRotation = toDegrees(Math.min(
+ Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)),
+ Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))
+ ));
+ labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));
+ }
+ this.labelRotation = labelRotation;
+ }
+ afterCalculateLabelRotation() {
+ callback(this.options.afterCalculateLabelRotation, [this]);
+ }
+ beforeFit() {
+ callback(this.options.beforeFit, [this]);
+ }
+ fit() {
+ const minSize = {
+ width: 0,
+ height: 0
+ };
+ const {chart, options: {ticks: tickOpts, title: titleOpts, grid: gridOpts}} = this;
+ const display = this._isVisible();
+ const isHorizontal = this.isHorizontal();
+ if (display) {
+ const titleHeight = getTitleHeight(titleOpts, chart.options.font);
+ if (isHorizontal) {
+ minSize.width = this.maxWidth;
+ minSize.height = getTickMarkLength(gridOpts) + titleHeight;
+ } else {
+ minSize.height = this.maxHeight;
+ minSize.width = getTickMarkLength(gridOpts) + titleHeight;
+ }
+ if (tickOpts.display && this.ticks.length) {
+ const {first, last, widest, highest} = this._getLabelSizes();
+ const tickPadding = tickOpts.padding * 2;
+ const angleRadians = toRadians(this.labelRotation);
+ const cos = Math.cos(angleRadians);
+ const sin = Math.sin(angleRadians);
+ if (isHorizontal) {
+ const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;
+ minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);
+ } else {
+ const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;
+ minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);
+ }
+ this._calculatePadding(first, last, sin, cos);
+ }
+ }
+ this._handleMargins();
+ if (isHorizontal) {
+ this.width = this._length = chart.width - this._margins.left - this._margins.right;
+ this.height = minSize.height;
+ } else {
+ this.width = minSize.width;
+ this.height = this._length = chart.height - this._margins.top - this._margins.bottom;
+ }
+ }
+ _calculatePadding(first, last, sin, cos) {
+ const {ticks: {align, padding}, position} = this.options;
+ const isRotated = this.labelRotation !== 0;
+ const labelsBelowTicks = position !== 'top' && this.axis === 'x';
+ if (this.isHorizontal()) {
+ const offsetLeft = this.getPixelForTick(0) - this.left;
+ const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);
+ let paddingLeft = 0;
+ let paddingRight = 0;
+ if (isRotated) {
+ if (labelsBelowTicks) {
+ paddingLeft = cos * first.width;
+ paddingRight = sin * last.height;
+ } else {
+ paddingLeft = sin * first.height;
+ paddingRight = cos * last.width;
+ }
+ } else if (align === 'start') {
+ paddingRight = last.width;
+ } else if (align === 'end') {
+ paddingLeft = first.width;
+ } else {
+ paddingLeft = first.width / 2;
+ paddingRight = last.width / 2;
+ }
+ this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);
+ this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);
+ } else {
+ let paddingTop = last.height / 2;
+ let paddingBottom = first.height / 2;
+ if (align === 'start') {
+ paddingTop = 0;
+ paddingBottom = first.height;
+ } else if (align === 'end') {
+ paddingTop = last.height;
+ paddingBottom = 0;
+ }
+ this.paddingTop = paddingTop + padding;
+ this.paddingBottom = paddingBottom + padding;
+ }
+ }
+ _handleMargins() {
+ if (this._margins) {
+ this._margins.left = Math.max(this.paddingLeft, this._margins.left);
+ this._margins.top = Math.max(this.paddingTop, this._margins.top);
+ this._margins.right = Math.max(this.paddingRight, this._margins.right);
+ this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);
+ }
+ }
+ afterFit() {
+ callback(this.options.afterFit, [this]);
+ }
+ isHorizontal() {
+ const {axis, position} = this.options;
+ return position === 'top' || position === 'bottom' || axis === 'x';
+ }
+ isFullSize() {
+ return this.options.fullSize;
+ }
+ _convertTicksToLabels(ticks) {
+ this.beforeTickToLabelConversion();
+ this.generateTickLabels(ticks);
+ let i, ilen;
+ for (i = 0, ilen = ticks.length; i < ilen; i++) {
+ if (isNullOrUndef(ticks[i].label)) {
+ ticks.splice(i, 1);
+ ilen--;
+ i--;
+ }
+ }
+ this.afterTickToLabelConversion();
+ }
+ _getLabelSizes() {
+ let labelSizes = this._labelSizes;
+ if (!labelSizes) {
+ const sampleSize = this.options.ticks.sampleSize;
+ let ticks = this.ticks;
+ if (sampleSize < ticks.length) {
+ ticks = sample(ticks, sampleSize);
+ }
+ this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length);
+ }
+ return labelSizes;
+ }
+ _computeLabelSizes(ticks, length) {
+ const {ctx, _longestTextCache: caches} = this;
+ const widths = [];
+ const heights = [];
+ let widestLabelSize = 0;
+ let highestLabelSize = 0;
+ let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;
+ for (i = 0; i < length; ++i) {
+ label = ticks[i].label;
+ tickFont = this._resolveTickFontOptions(i);
+ ctx.font = fontString = tickFont.string;
+ cache = caches[fontString] = caches[fontString] || {data: {}, gc: []};
+ lineHeight = tickFont.lineHeight;
+ width = height = 0;
+ if (!isNullOrUndef(label) && !isArray(label)) {
+ width = _measureText(ctx, cache.data, cache.gc, width, label);
+ height = lineHeight;
+ } else if (isArray(label)) {
+ for (j = 0, jlen = label.length; j < jlen; ++j) {
+ nestedLabel = label[j];
+ if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {
+ width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);
+ height += lineHeight;
+ }
+ }
+ }
+ widths.push(width);
+ heights.push(height);
+ widestLabelSize = Math.max(width, widestLabelSize);
+ highestLabelSize = Math.max(height, highestLabelSize);
+ }
+ garbageCollect(caches, length);
+ const widest = widths.indexOf(widestLabelSize);
+ const highest = heights.indexOf(highestLabelSize);
+ const valueAt = (idx) => ({width: widths[idx] || 0, height: heights[idx] || 0});
+ return {
+ first: valueAt(0),
+ last: valueAt(length - 1),
+ widest: valueAt(widest),
+ highest: valueAt(highest),
+ widths,
+ heights,
+ };
+ }
+ getLabelForValue(value) {
+ return value;
+ }
+ getPixelForValue(value, index) {
+ return NaN;
+ }
+ getValueForPixel(pixel) {}
+ getPixelForTick(index) {
+ const ticks = this.ticks;
+ if (index < 0 || index > ticks.length - 1) {
+ return null;
+ }
+ return this.getPixelForValue(ticks[index].value);
+ }
+ getPixelForDecimal(decimal) {
+ if (this._reversePixels) {
+ decimal = 1 - decimal;
+ }
+ const pixel = this._startPixel + decimal * this._length;
+ return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);
+ }
+ getDecimalForPixel(pixel) {
+ const decimal = (pixel - this._startPixel) / this._length;
+ return this._reversePixels ? 1 - decimal : decimal;
+ }
+ getBasePixel() {
+ return this.getPixelForValue(this.getBaseValue());
+ }
+ getBaseValue() {
+ const {min, max} = this;
+ return min < 0 && max < 0 ? max :
+ min > 0 && max > 0 ? min :
+ 0;
+ }
+ getContext(index) {
+ const ticks = this.ticks || [];
+ if (index >= 0 && index < ticks.length) {
+ const tick = ticks[index];
+ return tick.$context ||
+ (tick.$context = createTickContext(this.getContext(), index, tick));
+ }
+ return this.$context ||
+ (this.$context = createScaleContext(this.chart.getContext(), this));
+ }
+ _tickSize() {
+ const optionTicks = this.options.ticks;
+ const rot = toRadians(this.labelRotation);
+ const cos = Math.abs(Math.cos(rot));
+ const sin = Math.abs(Math.sin(rot));
+ const labelSizes = this._getLabelSizes();
+ const padding = optionTicks.autoSkipPadding || 0;
+ const w = labelSizes ? labelSizes.widest.width + padding : 0;
+ const h = labelSizes ? labelSizes.highest.height + padding : 0;
+ return this.isHorizontal()
+ ? h * cos > w * sin ? w / cos : h / sin
+ : h * sin < w * cos ? h / cos : w / sin;
+ }
+ _isVisible() {
+ const display = this.options.display;
+ if (display !== 'auto') {
+ return !!display;
+ }
+ return this.getMatchingVisibleMetas().length > 0;
+ }
+ _computeGridLineItems(chartArea) {
+ const axis = this.axis;
+ const chart = this.chart;
+ const options = this.options;
+ const {grid, position} = options;
+ const offset = grid.offset;
+ const isHorizontal = this.isHorizontal();
+ const ticks = this.ticks;
+ const ticksLength = ticks.length + (offset ? 1 : 0);
+ const tl = getTickMarkLength(grid);
+ const items = [];
+ const borderOpts = grid.setContext(this.getContext());
+ const axisWidth = borderOpts.drawBorder ? borderOpts.borderWidth : 0;
+ const axisHalfWidth = axisWidth / 2;
+ const alignBorderValue = function(pixel) {
+ return _alignPixel(chart, pixel, axisWidth);
+ };
+ let borderValue, i, lineValue, alignedLineValue;
+ let tx1, ty1, tx2, ty2, x1, y1, x2, y2;
+ if (position === 'top') {
+ borderValue = alignBorderValue(this.bottom);
+ ty1 = this.bottom - tl;
+ ty2 = borderValue - axisHalfWidth;
+ y1 = alignBorderValue(chartArea.top) + axisHalfWidth;
+ y2 = chartArea.bottom;
+ } else if (position === 'bottom') {
+ borderValue = alignBorderValue(this.top);
+ y1 = chartArea.top;
+ y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;
+ ty1 = borderValue + axisHalfWidth;
+ ty2 = this.top + tl;
+ } else if (position === 'left') {
+ borderValue = alignBorderValue(this.right);
+ tx1 = this.right - tl;
+ tx2 = borderValue - axisHalfWidth;
+ x1 = alignBorderValue(chartArea.left) + axisHalfWidth;
+ x2 = chartArea.right;
+ } else if (position === 'right') {
+ borderValue = alignBorderValue(this.left);
+ x1 = chartArea.left;
+ x2 = alignBorderValue(chartArea.right) - axisHalfWidth;
+ tx1 = borderValue + axisHalfWidth;
+ tx2 = this.left + tl;
+ } else if (axis === 'x') {
+ if (position === 'center') {
+ borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);
+ } else if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
+ }
+ y1 = chartArea.top;
+ y2 = chartArea.bottom;
+ ty1 = borderValue + axisHalfWidth;
+ ty2 = ty1 + tl;
+ } else if (axis === 'y') {
+ if (position === 'center') {
+ borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);
+ } else if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));
+ }
+ tx1 = borderValue - axisHalfWidth;
+ tx2 = tx1 - tl;
+ x1 = chartArea.left;
+ x2 = chartArea.right;
+ }
+ const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);
+ const step = Math.max(1, Math.ceil(ticksLength / limit));
+ for (i = 0; i < ticksLength; i += step) {
+ const optsAtIndex = grid.setContext(this.getContext(i));
+ const lineWidth = optsAtIndex.lineWidth;
+ const lineColor = optsAtIndex.color;
+ const borderDash = grid.borderDash || [];
+ const borderDashOffset = optsAtIndex.borderDashOffset;
+ const tickWidth = optsAtIndex.tickWidth;
+ const tickColor = optsAtIndex.tickColor;
+ const tickBorderDash = optsAtIndex.tickBorderDash || [];
+ const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;
+ lineValue = getPixelForGridLine(this, i, offset);
+ if (lineValue === undefined) {
+ continue;
+ }
+ alignedLineValue = _alignPixel(chart, lineValue, lineWidth);
+ if (isHorizontal) {
+ tx1 = tx2 = x1 = x2 = alignedLineValue;
+ } else {
+ ty1 = ty2 = y1 = y2 = alignedLineValue;
+ }
+ items.push({
+ tx1,
+ ty1,
+ tx2,
+ ty2,
+ x1,
+ y1,
+ x2,
+ y2,
+ width: lineWidth,
+ color: lineColor,
+ borderDash,
+ borderDashOffset,
+ tickWidth,
+ tickColor,
+ tickBorderDash,
+ tickBorderDashOffset,
+ });
+ }
+ this._ticksLength = ticksLength;
+ this._borderValue = borderValue;
+ return items;
+ }
+ _computeLabelItems(chartArea) {
+ const axis = this.axis;
+ const options = this.options;
+ const {position, ticks: optionTicks} = options;
+ const isHorizontal = this.isHorizontal();
+ const ticks = this.ticks;
+ const {align, crossAlign, padding, mirror} = optionTicks;
+ const tl = getTickMarkLength(options.grid);
+ const tickAndPadding = tl + padding;
+ const hTickAndPadding = mirror ? -padding : tickAndPadding;
+ const rotation = -toRadians(this.labelRotation);
+ const items = [];
+ let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset;
+ let textBaseline = 'middle';
+ if (position === 'top') {
+ y = this.bottom - hTickAndPadding;
+ textAlign = this._getXAxisLabelAlignment();
+ } else if (position === 'bottom') {
+ y = this.top + hTickAndPadding;
+ textAlign = this._getXAxisLabelAlignment();
+ } else if (position === 'left') {
+ const ret = this._getYAxisLabelAlignment(tl);
+ textAlign = ret.textAlign;
+ x = ret.x;
+ } else if (position === 'right') {
+ const ret = this._getYAxisLabelAlignment(tl);
+ textAlign = ret.textAlign;
+ x = ret.x;
+ } else if (axis === 'x') {
+ if (position === 'center') {
+ y = ((chartArea.top + chartArea.bottom) / 2) + tickAndPadding;
+ } else if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ y = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;
+ }
+ textAlign = this._getXAxisLabelAlignment();
+ } else if (axis === 'y') {
+ if (position === 'center') {
+ x = ((chartArea.left + chartArea.right) / 2) - tickAndPadding;
+ } else if (isObject(position)) {
+ const positionAxisID = Object.keys(position)[0];
+ const value = position[positionAxisID];
+ x = this.chart.scales[positionAxisID].getPixelForValue(value);
+ }
+ textAlign = this._getYAxisLabelAlignment(tl).textAlign;
+ }
+ if (axis === 'y') {
+ if (align === 'start') {
+ textBaseline = 'top';
+ } else if (align === 'end') {
+ textBaseline = 'bottom';
+ }
+ }
+ const labelSizes = this._getLabelSizes();
+ for (i = 0, ilen = ticks.length; i < ilen; ++i) {
+ tick = ticks[i];
+ label = tick.label;
+ const optsAtIndex = optionTicks.setContext(this.getContext(i));
+ pixel = this.getPixelForTick(i) + optionTicks.labelOffset;
+ font = this._resolveTickFontOptions(i);
+ lineHeight = font.lineHeight;
+ lineCount = isArray(label) ? label.length : 1;
+ const halfCount = lineCount / 2;
+ const color = optsAtIndex.color;
+ const strokeColor = optsAtIndex.textStrokeColor;
+ const strokeWidth = optsAtIndex.textStrokeWidth;
+ if (isHorizontal) {
+ x = pixel;
+ if (position === 'top') {
+ if (crossAlign === 'near' || rotation !== 0) {
+ textOffset = -lineCount * lineHeight + lineHeight / 2;
+ } else if (crossAlign === 'center') {
+ textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;
+ } else {
+ textOffset = -labelSizes.highest.height + lineHeight / 2;
+ }
+ } else {
+ if (crossAlign === 'near' || rotation !== 0) {
+ textOffset = lineHeight / 2;
+ } else if (crossAlign === 'center') {
+ textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;
+ } else {
+ textOffset = labelSizes.highest.height - lineCount * lineHeight;
+ }
+ }
+ if (mirror) {
+ textOffset *= -1;
+ }
+ } else {
+ y = pixel;
+ textOffset = (1 - lineCount) * lineHeight / 2;
+ }
+ let backdrop;
+ if (optsAtIndex.showLabelBackdrop) {
+ const labelPadding = toPadding(optsAtIndex.backdropPadding);
+ const height = labelSizes.heights[i];
+ const width = labelSizes.widths[i];
+ let top = y + textOffset - labelPadding.top;
+ let left = x - labelPadding.left;
+ switch (textBaseline) {
+ case 'middle':
+ top -= height / 2;
+ break;
+ case 'bottom':
+ top -= height;
+ break;
+ }
+ switch (textAlign) {
+ case 'center':
+ left -= width / 2;
+ break;
+ case 'right':
+ left -= width;
+ break;
+ }
+ backdrop = {
+ left,
+ top,
+ width: width + labelPadding.width,
+ height: height + labelPadding.height,
+ color: optsAtIndex.backdropColor,
+ };
+ }
+ items.push({
+ rotation,
+ label,
+ font,
+ color,
+ strokeColor,
+ strokeWidth,
+ textOffset,
+ textAlign,
+ textBaseline,
+ translation: [x, y],
+ backdrop,
+ });
+ }
+ return items;
+ }
+ _getXAxisLabelAlignment() {
+ const {position, ticks} = this.options;
+ const rotation = -toRadians(this.labelRotation);
+ if (rotation) {
+ return position === 'top' ? 'left' : 'right';
+ }
+ let align = 'center';
+ if (ticks.align === 'start') {
+ align = 'left';
+ } else if (ticks.align === 'end') {
+ align = 'right';
+ }
+ return align;
+ }
+ _getYAxisLabelAlignment(tl) {
+ const {position, ticks: {crossAlign, mirror, padding}} = this.options;
+ const labelSizes = this._getLabelSizes();
+ const tickAndPadding = tl + padding;
+ const widest = labelSizes.widest.width;
+ let textAlign;
+ let x;
+ if (position === 'left') {
+ if (mirror) {
+ x = this.right + padding;
+ if (crossAlign === 'near') {
+ textAlign = 'left';
+ } else if (crossAlign === 'center') {
+ textAlign = 'center';
+ x += (widest / 2);
+ } else {
+ textAlign = 'right';
+ x += widest;
+ }
+ } else {
+ x = this.right - tickAndPadding;
+ if (crossAlign === 'near') {
+ textAlign = 'right';
+ } else if (crossAlign === 'center') {
+ textAlign = 'center';
+ x -= (widest / 2);
+ } else {
+ textAlign = 'left';
+ x = this.left;
+ }
+ }
+ } else if (position === 'right') {
+ if (mirror) {
+ x = this.left + padding;
+ if (crossAlign === 'near') {
+ textAlign = 'right';
+ } else if (crossAlign === 'center') {
+ textAlign = 'center';
+ x -= (widest / 2);
+ } else {
+ textAlign = 'left';
+ x -= widest;
+ }
+ } else {
+ x = this.left + tickAndPadding;
+ if (crossAlign === 'near') {
+ textAlign = 'left';
+ } else if (crossAlign === 'center') {
+ textAlign = 'center';
+ x += widest / 2;
+ } else {
+ textAlign = 'right';
+ x = this.right;
+ }
+ }
+ } else {
+ textAlign = 'right';
+ }
+ return {textAlign, x};
+ }
+ _computeLabelArea() {
+ if (this.options.ticks.mirror) {
+ return;
+ }
+ const chart = this.chart;
+ const position = this.options.position;
+ if (position === 'left' || position === 'right') {
+ return {top: 0, left: this.left, bottom: chart.height, right: this.right};
+ } if (position === 'top' || position === 'bottom') {
+ return {top: this.top, left: 0, bottom: this.bottom, right: chart.width};
+ }
+ }
+ drawBackground() {
+ const {ctx, options: {backgroundColor}, left, top, width, height} = this;
+ if (backgroundColor) {
+ ctx.save();
+ ctx.fillStyle = backgroundColor;
+ ctx.fillRect(left, top, width, height);
+ ctx.restore();
+ }
+ }
+ getLineWidthForValue(value) {
+ const grid = this.options.grid;
+ if (!this._isVisible() || !grid.display) {
+ return 0;
+ }
+ const ticks = this.ticks;
+ const index = ticks.findIndex(t => t.value === value);
+ if (index >= 0) {
+ const opts = grid.setContext(this.getContext(index));
+ return opts.lineWidth;
+ }
+ return 0;
+ }
+ drawGrid(chartArea) {
+ const grid = this.options.grid;
+ const ctx = this.ctx;
+ const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));
+ let i, ilen;
+ const drawLine = (p1, p2, style) => {
+ if (!style.width || !style.color) {
+ return;
+ }
+ ctx.save();
+ ctx.lineWidth = style.width;
+ ctx.strokeStyle = style.color;
+ ctx.setLineDash(style.borderDash || []);
+ ctx.lineDashOffset = style.borderDashOffset;
+ ctx.beginPath();
+ ctx.moveTo(p1.x, p1.y);
+ ctx.lineTo(p2.x, p2.y);
+ ctx.stroke();
+ ctx.restore();
+ };
+ if (grid.display) {
+ for (i = 0, ilen = items.length; i < ilen; ++i) {
+ const item = items[i];
+ if (grid.drawOnChartArea) {
+ drawLine(
+ {x: item.x1, y: item.y1},
+ {x: item.x2, y: item.y2},
+ item
+ );
+ }
+ if (grid.drawTicks) {
+ drawLine(
+ {x: item.tx1, y: item.ty1},
+ {x: item.tx2, y: item.ty2},
+ {
+ color: item.tickColor,
+ width: item.tickWidth,
+ borderDash: item.tickBorderDash,
+ borderDashOffset: item.tickBorderDashOffset
+ }
+ );
+ }
+ }
+ }
+ }
+ drawBorder() {
+ const {chart, ctx, options: {grid}} = this;
+ const borderOpts = grid.setContext(this.getContext());
+ const axisWidth = grid.drawBorder ? borderOpts.borderWidth : 0;
+ if (!axisWidth) {
+ return;
+ }
+ const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;
+ const borderValue = this._borderValue;
+ let x1, x2, y1, y2;
+ if (this.isHorizontal()) {
+ x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;
+ x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;
+ y1 = y2 = borderValue;
+ } else {
+ y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;
+ y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;
+ x1 = x2 = borderValue;
+ }
+ ctx.save();
+ ctx.lineWidth = borderOpts.borderWidth;
+ ctx.strokeStyle = borderOpts.borderColor;
+ ctx.beginPath();
+ ctx.moveTo(x1, y1);
+ ctx.lineTo(x2, y2);
+ ctx.stroke();
+ ctx.restore();
+ }
+ drawLabels(chartArea) {
+ const optionTicks = this.options.ticks;
+ if (!optionTicks.display) {
+ return;
+ }
+ const ctx = this.ctx;
+ const area = this._computeLabelArea();
+ if (area) {
+ clipArea(ctx, area);
+ }
+ const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));
+ let i, ilen;
+ for (i = 0, ilen = items.length; i < ilen; ++i) {
+ const item = items[i];
+ const tickFont = item.font;
+ const label = item.label;
+ if (item.backdrop) {
+ ctx.fillStyle = item.backdrop.color;
+ ctx.fillRect(item.backdrop.left, item.backdrop.top, item.backdrop.width, item.backdrop.height);
+ }
+ let y = item.textOffset;
+ renderText(ctx, label, 0, y, tickFont, item);
+ }
+ if (area) {
+ unclipArea(ctx);
+ }
+ }
+ drawTitle() {
+ const {ctx, options: {position, title, reverse}} = this;
+ if (!title.display) {
+ return;
+ }
+ const font = toFont(title.font);
+ const padding = toPadding(title.padding);
+ const align = title.align;
+ let offset = font.lineHeight / 2;
+ if (position === 'bottom' || position === 'center' || isObject(position)) {
+ offset += padding.bottom;
+ if (isArray(title.text)) {
+ offset += font.lineHeight * (title.text.length - 1);
+ }
+ } else {
+ offset += padding.top;
+ }
+ const {titleX, titleY, maxWidth, rotation} = titleArgs(this, offset, position, align);
+ renderText(ctx, title.text, 0, 0, font, {
+ color: title.color,
+ maxWidth,
+ rotation,
+ textAlign: titleAlign(align, position, reverse),
+ textBaseline: 'middle',
+ translation: [titleX, titleY],
+ });
+ }
+ draw(chartArea) {
+ if (!this._isVisible()) {
+ return;
+ }
+ this.drawBackground();
+ this.drawGrid(chartArea);
+ this.drawBorder();
+ this.drawTitle();
+ this.drawLabels(chartArea);
+ }
+ _layers() {
+ const opts = this.options;
+ const tz = opts.ticks && opts.ticks.z || 0;
+ const gz = valueOrDefault(opts.grid && opts.grid.z, -1);
+ if (!this._isVisible() || this.draw !== Scale.prototype.draw) {
+ return [{
+ z: tz,
+ draw: (chartArea) => {
+ this.draw(chartArea);
+ }
+ }];
+ }
+ return [{
+ z: gz,
+ draw: (chartArea) => {
+ this.drawBackground();
+ this.drawGrid(chartArea);
+ this.drawTitle();
+ }
+ }, {
+ z: gz + 1,
+ draw: () => {
+ this.drawBorder();
+ }
+ }, {
+ z: tz,
+ draw: (chartArea) => {
+ this.drawLabels(chartArea);
+ }
+ }];
+ }
+ getMatchingVisibleMetas(type) {
+ const metas = this.chart.getSortedVisibleDatasetMetas();
+ const axisID = this.axis + 'AxisID';
+ const result = [];
+ let i, ilen;
+ for (i = 0, ilen = metas.length; i < ilen; ++i) {
+ const meta = metas[i];
+ if (meta[axisID] === this.id && (!type || meta.type === type)) {
+ result.push(meta);
+ }
+ }
+ return result;
+ }
+ _resolveTickFontOptions(index) {
+ const opts = this.options.ticks.setContext(this.getContext(index));
+ return toFont(opts.font);
+ }
+ _maxDigits() {
+ const fontSize = this._resolveTickFontOptions(0).lineHeight;
+ return (this.isHorizontal() ? this.width : this.height) / fontSize;
+ }
+}
+
+class TypedRegistry {
+ constructor(type, scope, override) {
+ this.type = type;
+ this.scope = scope;
+ this.override = override;
+ this.items = Object.create(null);
+ }
+ isForType(type) {
+ return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);
+ }
+ register(item) {
+ const proto = Object.getPrototypeOf(item);
+ let parentScope;
+ if (isIChartComponent(proto)) {
+ parentScope = this.register(proto);
+ }
+ const items = this.items;
+ const id = item.id;
+ const scope = this.scope + '.' + id;
+ if (!id) {
+ throw new Error('class does not have id: ' + item);
+ }
+ if (id in items) {
+ return scope;
+ }
+ items[id] = item;
+ registerDefaults(item, scope, parentScope);
+ if (this.override) {
+ defaults.override(item.id, item.overrides);
+ }
+ return scope;
+ }
+ get(id) {
+ return this.items[id];
+ }
+ unregister(item) {
+ const items = this.items;
+ const id = item.id;
+ const scope = this.scope;
+ if (id in items) {
+ delete items[id];
+ }
+ if (scope && id in defaults[scope]) {
+ delete defaults[scope][id];
+ if (this.override) {
+ delete overrides[id];
+ }
+ }
+ }
+}
+function registerDefaults(item, scope, parentScope) {
+ const itemDefaults = merge(Object.create(null), [
+ parentScope ? defaults.get(parentScope) : {},
+ defaults.get(scope),
+ item.defaults
+ ]);
+ defaults.set(scope, itemDefaults);
+ if (item.defaultRoutes) {
+ routeDefaults(scope, item.defaultRoutes);
+ }
+ if (item.descriptors) {
+ defaults.describe(scope, item.descriptors);
+ }
+}
+function routeDefaults(scope, routes) {
+ Object.keys(routes).forEach(property => {
+ const propertyParts = property.split('.');
+ const sourceName = propertyParts.pop();
+ const sourceScope = [scope].concat(propertyParts).join('.');
+ const parts = routes[property].split('.');
+ const targetName = parts.pop();
+ const targetScope = parts.join('.');
+ defaults.route(sourceScope, sourceName, targetScope, targetName);
+ });
+}
+function isIChartComponent(proto) {
+ return 'id' in proto && 'defaults' in proto;
+}
+
+class Registry {
+ constructor() {
+ this.controllers = new TypedRegistry(DatasetController, 'datasets', true);
+ this.elements = new TypedRegistry(Element, 'elements');
+ this.plugins = new TypedRegistry(Object, 'plugins');
+ this.scales = new TypedRegistry(Scale, 'scales');
+ this._typedRegistries = [this.controllers, this.scales, this.elements];
+ }
+ add(...args) {
+ this._each('register', args);
+ }
+ remove(...args) {
+ this._each('unregister', args);
+ }
+ addControllers(...args) {
+ this._each('register', args, this.controllers);
+ }
+ addElements(...args) {
+ this._each('register', args, this.elements);
+ }
+ addPlugins(...args) {
+ this._each('register', args, this.plugins);
+ }
+ addScales(...args) {
+ this._each('register', args, this.scales);
+ }
+ getController(id) {
+ return this._get(id, this.controllers, 'controller');
+ }
+ getElement(id) {
+ return this._get(id, this.elements, 'element');
+ }
+ getPlugin(id) {
+ return this._get(id, this.plugins, 'plugin');
+ }
+ getScale(id) {
+ return this._get(id, this.scales, 'scale');
+ }
+ removeControllers(...args) {
+ this._each('unregister', args, this.controllers);
+ }
+ removeElements(...args) {
+ this._each('unregister', args, this.elements);
+ }
+ removePlugins(...args) {
+ this._each('unregister', args, this.plugins);
+ }
+ removeScales(...args) {
+ this._each('unregister', args, this.scales);
+ }
+ _each(method, args, typedRegistry) {
+ [...args].forEach(arg => {
+ const reg = typedRegistry || this._getRegistryForType(arg);
+ if (typedRegistry || reg.isForType(arg) || (reg === this.plugins && arg.id)) {
+ this._exec(method, reg, arg);
+ } else {
+ each(arg, item => {
+ const itemReg = typedRegistry || this._getRegistryForType(item);
+ this._exec(method, itemReg, item);
+ });
+ }
+ });
+ }
+ _exec(method, registry, component) {
+ const camelMethod = _capitalize(method);
+ callback(component['before' + camelMethod], [], component);
+ registry[method](component);
+ callback(component['after' + camelMethod], [], component);
+ }
+ _getRegistryForType(type) {
+ for (let i = 0; i < this._typedRegistries.length; i++) {
+ const reg = this._typedRegistries[i];
+ if (reg.isForType(type)) {
+ return reg;
+ }
+ }
+ return this.plugins;
+ }
+ _get(id, typedRegistry, type) {
+ const item = typedRegistry.get(id);
+ if (item === undefined) {
+ throw new Error('"' + id + '" is not a registered ' + type + '.');
+ }
+ return item;
+ }
+}
+var registry = new Registry();
+
+class PluginService {
+ constructor() {
+ this._init = [];
+ }
+ notify(chart, hook, args, filter) {
+ if (hook === 'beforeInit') {
+ this._init = this._createDescriptors(chart, true);
+ this._notify(this._init, chart, 'install');
+ }
+ const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart);
+ const result = this._notify(descriptors, chart, hook, args);
+ if (hook === 'afterDestroy') {
+ this._notify(descriptors, chart, 'stop');
+ this._notify(this._init, chart, 'uninstall');
+ }
+ return result;
+ }
+ _notify(descriptors, chart, hook, args) {
+ args = args || {};
+ for (const descriptor of descriptors) {
+ const plugin = descriptor.plugin;
+ const method = plugin[hook];
+ const params = [chart, args, descriptor.options];
+ if (callback(method, params, plugin) === false && args.cancelable) {
+ return false;
+ }
+ }
+ return true;
+ }
+ invalidate() {
+ if (!isNullOrUndef(this._cache)) {
+ this._oldCache = this._cache;
+ this._cache = undefined;
+ }
+ }
+ _descriptors(chart) {
+ if (this._cache) {
+ return this._cache;
+ }
+ const descriptors = this._cache = this._createDescriptors(chart);
+ this._notifyStateChanges(chart);
+ return descriptors;
+ }
+ _createDescriptors(chart, all) {
+ const config = chart && chart.config;
+ const options = valueOrDefault(config.options && config.options.plugins, {});
+ const plugins = allPlugins(config);
+ return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);
+ }
+ _notifyStateChanges(chart) {
+ const previousDescriptors = this._oldCache || [];
+ const descriptors = this._cache;
+ const diff = (a, b) => a.filter(x => !b.some(y => x.plugin.id === y.plugin.id));
+ this._notify(diff(previousDescriptors, descriptors), chart, 'stop');
+ this._notify(diff(descriptors, previousDescriptors), chart, 'start');
+ }
+}
+function allPlugins(config) {
+ const plugins = [];
+ const keys = Object.keys(registry.plugins.items);
+ for (let i = 0; i < keys.length; i++) {
+ plugins.push(registry.getPlugin(keys[i]));
+ }
+ const local = config.plugins || [];
+ for (let i = 0; i < local.length; i++) {
+ const plugin = local[i];
+ if (plugins.indexOf(plugin) === -1) {
+ plugins.push(plugin);
+ }
+ }
+ return plugins;
+}
+function getOpts(options, all) {
+ if (!all && options === false) {
+ return null;
+ }
+ if (options === true) {
+ return {};
+ }
+ return options;
+}
+function createDescriptors(chart, plugins, options, all) {
+ const result = [];
+ const context = chart.getContext();
+ for (let i = 0; i < plugins.length; i++) {
+ const plugin = plugins[i];
+ const id = plugin.id;
+ const opts = getOpts(options[id], all);
+ if (opts === null) {
+ continue;
+ }
+ result.push({
+ plugin,
+ options: pluginOpts(chart.config, plugin, opts, context)
+ });
+ }
+ return result;
+}
+function pluginOpts(config, plugin, opts, context) {
+ const keys = config.pluginScopeKeys(plugin);
+ const scopes = config.getOptionScopes(opts, keys);
+ return config.createResolver(scopes, context, [''], {scriptable: false, indexable: false, allKeys: true});
+}
+
+function getIndexAxis(type, options) {
+ const datasetDefaults = defaults.datasets[type] || {};
+ const datasetOptions = (options.datasets || {})[type] || {};
+ return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x';
+}
+function getAxisFromDefaultScaleID(id, indexAxis) {
+ let axis = id;
+ if (id === '_index_') {
+ axis = indexAxis;
+ } else if (id === '_value_') {
+ axis = indexAxis === 'x' ? 'y' : 'x';
+ }
+ return axis;
+}
+function getDefaultScaleIDFromAxis(axis, indexAxis) {
+ return axis === indexAxis ? '_index_' : '_value_';
+}
+function axisFromPosition(position) {
+ if (position === 'top' || position === 'bottom') {
+ return 'x';
+ }
+ if (position === 'left' || position === 'right') {
+ return 'y';
+ }
+}
+function determineAxis(id, scaleOptions) {
+ if (id === 'x' || id === 'y') {
+ return id;
+ }
+ return scaleOptions.axis || axisFromPosition(scaleOptions.position) || id.charAt(0).toLowerCase();
+}
+function mergeScaleConfig(config, options) {
+ const chartDefaults = overrides[config.type] || {scales: {}};
+ const configScales = options.scales || {};
+ const chartIndexAxis = getIndexAxis(config.type, options);
+ const firstIDs = Object.create(null);
+ const scales = Object.create(null);
+ Object.keys(configScales).forEach(id => {
+ const scaleConf = configScales[id];
+ if (!isObject(scaleConf)) {
+ return console.error(`Invalid scale configuration for scale: ${id}`);
+ }
+ if (scaleConf._proxy) {
+ return console.warn(`Ignoring resolver passed as options for scale: ${id}`);
+ }
+ const axis = determineAxis(id, scaleConf);
+ const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);
+ const defaultScaleOptions = chartDefaults.scales || {};
+ firstIDs[axis] = firstIDs[axis] || id;
+ scales[id] = mergeIf(Object.create(null), [{axis}, scaleConf, defaultScaleOptions[axis], defaultScaleOptions[defaultId]]);
+ });
+ config.data.datasets.forEach(dataset => {
+ const type = dataset.type || config.type;
+ const indexAxis = dataset.indexAxis || getIndexAxis(type, options);
+ const datasetDefaults = overrides[type] || {};
+ const defaultScaleOptions = datasetDefaults.scales || {};
+ Object.keys(defaultScaleOptions).forEach(defaultID => {
+ const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);
+ const id = dataset[axis + 'AxisID'] || firstIDs[axis] || axis;
+ scales[id] = scales[id] || Object.create(null);
+ mergeIf(scales[id], [{axis}, configScales[id], defaultScaleOptions[defaultID]]);
+ });
+ });
+ Object.keys(scales).forEach(key => {
+ const scale = scales[key];
+ mergeIf(scale, [defaults.scales[scale.type], defaults.scale]);
+ });
+ return scales;
+}
+function initOptions(config) {
+ const options = config.options || (config.options = {});
+ options.plugins = valueOrDefault(options.plugins, {});
+ options.scales = mergeScaleConfig(config, options);
+}
+function initData(data) {
+ data = data || {};
+ data.datasets = data.datasets || [];
+ data.labels = data.labels || [];
+ return data;
+}
+function initConfig(config) {
+ config = config || {};
+ config.data = initData(config.data);
+ initOptions(config);
+ return config;
+}
+const keyCache = new Map();
+const keysCached = new Set();
+function cachedKeys(cacheKey, generate) {
+ let keys = keyCache.get(cacheKey);
+ if (!keys) {
+ keys = generate();
+ keyCache.set(cacheKey, keys);
+ keysCached.add(keys);
+ }
+ return keys;
+}
+const addIfFound = (set, obj, key) => {
+ const opts = resolveObjectKey(obj, key);
+ if (opts !== undefined) {
+ set.add(opts);
+ }
+};
+class Config {
+ constructor(config) {
+ this._config = initConfig(config);
+ this._scopeCache = new Map();
+ this._resolverCache = new Map();
+ }
+ get platform() {
+ return this._config.platform;
+ }
+ get type() {
+ return this._config.type;
+ }
+ set type(type) {
+ this._config.type = type;
+ }
+ get data() {
+ return this._config.data;
+ }
+ set data(data) {
+ this._config.data = initData(data);
+ }
+ get options() {
+ return this._config.options;
+ }
+ set options(options) {
+ this._config.options = options;
+ }
+ get plugins() {
+ return this._config.plugins;
+ }
+ update() {
+ const config = this._config;
+ this.clearCache();
+ initOptions(config);
+ }
+ clearCache() {
+ this._scopeCache.clear();
+ this._resolverCache.clear();
+ }
+ datasetScopeKeys(datasetType) {
+ return cachedKeys(datasetType,
+ () => [[
+ `datasets.${datasetType}`,
+ ''
+ ]]);
+ }
+ datasetAnimationScopeKeys(datasetType, transition) {
+ return cachedKeys(`${datasetType}.transition.${transition}`,
+ () => [
+ [
+ `datasets.${datasetType}.transitions.${transition}`,
+ `transitions.${transition}`,
+ ],
+ [
+ `datasets.${datasetType}`,
+ ''
+ ]
+ ]);
+ }
+ datasetElementScopeKeys(datasetType, elementType) {
+ return cachedKeys(`${datasetType}-${elementType}`,
+ () => [[
+ `datasets.${datasetType}.elements.${elementType}`,
+ `datasets.${datasetType}`,
+ `elements.${elementType}`,
+ ''
+ ]]);
+ }
+ pluginScopeKeys(plugin) {
+ const id = plugin.id;
+ const type = this.type;
+ return cachedKeys(`${type}-plugin-${id}`,
+ () => [[
+ `plugins.${id}`,
+ ...plugin.additionalOptionScopes || [],
+ ]]);
+ }
+ _cachedScopes(mainScope, resetCache) {
+ const _scopeCache = this._scopeCache;
+ let cache = _scopeCache.get(mainScope);
+ if (!cache || resetCache) {
+ cache = new Map();
+ _scopeCache.set(mainScope, cache);
+ }
+ return cache;
+ }
+ getOptionScopes(mainScope, keyLists, resetCache) {
+ const {options, type} = this;
+ const cache = this._cachedScopes(mainScope, resetCache);
+ const cached = cache.get(keyLists);
+ if (cached) {
+ return cached;
+ }
+ const scopes = new Set();
+ keyLists.forEach(keys => {
+ if (mainScope) {
+ scopes.add(mainScope);
+ keys.forEach(key => addIfFound(scopes, mainScope, key));
+ }
+ keys.forEach(key => addIfFound(scopes, options, key));
+ keys.forEach(key => addIfFound(scopes, overrides[type] || {}, key));
+ keys.forEach(key => addIfFound(scopes, defaults, key));
+ keys.forEach(key => addIfFound(scopes, descriptors, key));
+ });
+ const array = Array.from(scopes);
+ if (array.length === 0) {
+ array.push(Object.create(null));
+ }
+ if (keysCached.has(keyLists)) {
+ cache.set(keyLists, array);
+ }
+ return array;
+ }
+ chartOptionScopes() {
+ const {options, type} = this;
+ return [
+ options,
+ overrides[type] || {},
+ defaults.datasets[type] || {},
+ {type},
+ defaults,
+ descriptors
+ ];
+ }
+ resolveNamedOptions(scopes, names, context, prefixes = ['']) {
+ const result = {$shared: true};
+ const {resolver, subPrefixes} = getResolver(this._resolverCache, scopes, prefixes);
+ let options = resolver;
+ if (needContext(resolver, names)) {
+ result.$shared = false;
+ context = isFunction(context) ? context() : context;
+ const subResolver = this.createResolver(scopes, context, subPrefixes);
+ options = _attachContext(resolver, context, subResolver);
+ }
+ for (const prop of names) {
+ result[prop] = options[prop];
+ }
+ return result;
+ }
+ createResolver(scopes, context, prefixes = [''], descriptorDefaults) {
+ const {resolver} = getResolver(this._resolverCache, scopes, prefixes);
+ return isObject(context)
+ ? _attachContext(resolver, context, undefined, descriptorDefaults)
+ : resolver;
+ }
+}
+function getResolver(resolverCache, scopes, prefixes) {
+ let cache = resolverCache.get(scopes);
+ if (!cache) {
+ cache = new Map();
+ resolverCache.set(scopes, cache);
+ }
+ const cacheKey = prefixes.join();
+ let cached = cache.get(cacheKey);
+ if (!cached) {
+ const resolver = _createResolver(scopes, prefixes);
+ cached = {
+ resolver,
+ subPrefixes: prefixes.filter(p => !p.toLowerCase().includes('hover'))
+ };
+ cache.set(cacheKey, cached);
+ }
+ return cached;
+}
+const hasFunction = value => isObject(value)
+ && Object.getOwnPropertyNames(value).reduce((acc, key) => acc || isFunction(value[key]), false);
+function needContext(proxy, names) {
+ const {isScriptable, isIndexable} = _descriptors(proxy);
+ for (const prop of names) {
+ const scriptable = isScriptable(prop);
+ const indexable = isIndexable(prop);
+ const value = (indexable || scriptable) && proxy[prop];
+ if ((scriptable && (isFunction(value) || hasFunction(value)))
+ || (indexable && isArray(value))) {
+ return true;
+ }
+ }
+ return false;
+}
+
+var version = "3.7.1";
+
+const KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea'];
+function positionIsHorizontal(position, axis) {
+ return position === 'top' || position === 'bottom' || (KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x');
+}
+function compare2Level(l1, l2) {
+ return function(a, b) {
+ return a[l1] === b[l1]
+ ? a[l2] - b[l2]
+ : a[l1] - b[l1];
+ };
+}
+function onAnimationsComplete(context) {
+ const chart = context.chart;
+ const animationOptions = chart.options.animation;
+ chart.notifyPlugins('afterRender');
+ callback(animationOptions && animationOptions.onComplete, [context], chart);
+}
+function onAnimationProgress(context) {
+ const chart = context.chart;
+ const animationOptions = chart.options.animation;
+ callback(animationOptions && animationOptions.onProgress, [context], chart);
+}
+function getCanvas(item) {
+ if (_isDomSupported() && typeof item === 'string') {
+ item = document.getElementById(item);
+ } else if (item && item.length) {
+ item = item[0];
+ }
+ if (item && item.canvas) {
+ item = item.canvas;
+ }
+ return item;
+}
+const instances = {};
+const getChart = (key) => {
+ const canvas = getCanvas(key);
+ return Object.values(instances).filter((c) => c.canvas === canvas).pop();
+};
+function moveNumericKeys(obj, start, move) {
+ const keys = Object.keys(obj);
+ for (const key of keys) {
+ const intKey = +key;
+ if (intKey >= start) {
+ const value = obj[key];
+ delete obj[key];
+ if (move > 0 || intKey > start) {
+ obj[intKey + move] = value;
+ }
+ }
+ }
+}
+function determineLastEvent(e, lastEvent, inChartArea, isClick) {
+ if (!inChartArea || e.type === 'mouseout') {
+ return null;
+ }
+ if (isClick) {
+ return lastEvent;
+ }
+ return e;
+}
+class Chart {
+ constructor(item, userConfig) {
+ const config = this.config = new Config(userConfig);
+ const initialCanvas = getCanvas(item);
+ const existingChart = getChart(initialCanvas);
+ if (existingChart) {
+ throw new Error(
+ 'Canvas is already in use. Chart with ID \'' + existingChart.id + '\'' +
+ ' must be destroyed before the canvas can be reused.'
+ );
+ }
+ const options = config.createResolver(config.chartOptionScopes(), this.getContext());
+ this.platform = new (config.platform || _detectPlatform(initialCanvas))();
+ this.platform.updateConfig(config);
+ const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);
+ const canvas = context && context.canvas;
+ const height = canvas && canvas.height;
+ const width = canvas && canvas.width;
+ this.id = uid();
+ this.ctx = context;
+ this.canvas = canvas;
+ this.width = width;
+ this.height = height;
+ this._options = options;
+ this._aspectRatio = this.aspectRatio;
+ this._layers = [];
+ this._metasets = [];
+ this._stacks = undefined;
+ this.boxes = [];
+ this.currentDevicePixelRatio = undefined;
+ this.chartArea = undefined;
+ this._active = [];
+ this._lastEvent = undefined;
+ this._listeners = {};
+ this._responsiveListeners = undefined;
+ this._sortedMetasets = [];
+ this.scales = {};
+ this._plugins = new PluginService();
+ this.$proxies = {};
+ this._hiddenIndices = {};
+ this.attached = false;
+ this._animationsDisabled = undefined;
+ this.$context = undefined;
+ this._doResize = debounce(mode => this.update(mode), options.resizeDelay || 0);
+ this._dataChanges = [];
+ instances[this.id] = this;
+ if (!context || !canvas) {
+ console.error("Failed to create chart: can't acquire context from the given item");
+ return;
+ }
+ animator.listen(this, 'complete', onAnimationsComplete);
+ animator.listen(this, 'progress', onAnimationProgress);
+ this._initialize();
+ if (this.attached) {
+ this.update();
+ }
+ }
+ get aspectRatio() {
+ const {options: {aspectRatio, maintainAspectRatio}, width, height, _aspectRatio} = this;
+ if (!isNullOrUndef(aspectRatio)) {
+ return aspectRatio;
+ }
+ if (maintainAspectRatio && _aspectRatio) {
+ return _aspectRatio;
+ }
+ return height ? width / height : null;
+ }
+ get data() {
+ return this.config.data;
+ }
+ set data(data) {
+ this.config.data = data;
+ }
+ get options() {
+ return this._options;
+ }
+ set options(options) {
+ this.config.options = options;
+ }
+ _initialize() {
+ this.notifyPlugins('beforeInit');
+ if (this.options.responsive) {
+ this.resize();
+ } else {
+ retinaScale(this, this.options.devicePixelRatio);
+ }
+ this.bindEvents();
+ this.notifyPlugins('afterInit');
+ return this;
+ }
+ clear() {
+ clearCanvas(this.canvas, this.ctx);
+ return this;
+ }
+ stop() {
+ animator.stop(this);
+ return this;
+ }
+ resize(width, height) {
+ if (!animator.running(this)) {
+ this._resize(width, height);
+ } else {
+ this._resizeBeforeDraw = {width, height};
+ }
+ }
+ _resize(width, height) {
+ const options = this.options;
+ const canvas = this.canvas;
+ const aspectRatio = options.maintainAspectRatio && this.aspectRatio;
+ const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);
+ const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();
+ const mode = this.width ? 'resize' : 'attach';
+ this.width = newSize.width;
+ this.height = newSize.height;
+ this._aspectRatio = this.aspectRatio;
+ if (!retinaScale(this, newRatio, true)) {
+ return;
+ }
+ this.notifyPlugins('resize', {size: newSize});
+ callback(options.onResize, [this, newSize], this);
+ if (this.attached) {
+ if (this._doResize(mode)) {
+ this.render();
+ }
+ }
+ }
+ ensureScalesHaveIDs() {
+ const options = this.options;
+ const scalesOptions = options.scales || {};
+ each(scalesOptions, (axisOptions, axisID) => {
+ axisOptions.id = axisID;
+ });
+ }
+ buildOrUpdateScales() {
+ const options = this.options;
+ const scaleOpts = options.scales;
+ const scales = this.scales;
+ const updated = Object.keys(scales).reduce((obj, id) => {
+ obj[id] = false;
+ return obj;
+ }, {});
+ let items = [];
+ if (scaleOpts) {
+ items = items.concat(
+ Object.keys(scaleOpts).map((id) => {
+ const scaleOptions = scaleOpts[id];
+ const axis = determineAxis(id, scaleOptions);
+ const isRadial = axis === 'r';
+ const isHorizontal = axis === 'x';
+ return {
+ options: scaleOptions,
+ dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left',
+ dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear'
+ };
+ })
+ );
+ }
+ each(items, (item) => {
+ const scaleOptions = item.options;
+ const id = scaleOptions.id;
+ const axis = determineAxis(id, scaleOptions);
+ const scaleType = valueOrDefault(scaleOptions.type, item.dtype);
+ if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {
+ scaleOptions.position = item.dposition;
+ }
+ updated[id] = true;
+ let scale = null;
+ if (id in scales && scales[id].type === scaleType) {
+ scale = scales[id];
+ } else {
+ const scaleClass = registry.getScale(scaleType);
+ scale = new scaleClass({
+ id,
+ type: scaleType,
+ ctx: this.ctx,
+ chart: this
+ });
+ scales[scale.id] = scale;
+ }
+ scale.init(scaleOptions, options);
+ });
+ each(updated, (hasUpdated, id) => {
+ if (!hasUpdated) {
+ delete scales[id];
+ }
+ });
+ each(scales, (scale) => {
+ layouts.configure(this, scale, scale.options);
+ layouts.addBox(this, scale);
+ });
+ }
+ _updateMetasets() {
+ const metasets = this._metasets;
+ const numData = this.data.datasets.length;
+ const numMeta = metasets.length;
+ metasets.sort((a, b) => a.index - b.index);
+ if (numMeta > numData) {
+ for (let i = numData; i < numMeta; ++i) {
+ this._destroyDatasetMeta(i);
+ }
+ metasets.splice(numData, numMeta - numData);
+ }
+ this._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index'));
+ }
+ _removeUnreferencedMetasets() {
+ const {_metasets: metasets, data: {datasets}} = this;
+ if (metasets.length > datasets.length) {
+ delete this._stacks;
+ }
+ metasets.forEach((meta, index) => {
+ if (datasets.filter(x => x === meta._dataset).length === 0) {
+ this._destroyDatasetMeta(index);
+ }
+ });
+ }
+ buildOrUpdateControllers() {
+ const newControllers = [];
+ const datasets = this.data.datasets;
+ let i, ilen;
+ this._removeUnreferencedMetasets();
+ for (i = 0, ilen = datasets.length; i < ilen; i++) {
+ const dataset = datasets[i];
+ let meta = this.getDatasetMeta(i);
+ const type = dataset.type || this.config.type;
+ if (meta.type && meta.type !== type) {
+ this._destroyDatasetMeta(i);
+ meta = this.getDatasetMeta(i);
+ }
+ meta.type = type;
+ meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);
+ meta.order = dataset.order || 0;
+ meta.index = i;
+ meta.label = '' + dataset.label;
+ meta.visible = this.isDatasetVisible(i);
+ if (meta.controller) {
+ meta.controller.updateIndex(i);
+ meta.controller.linkScales();
+ } else {
+ const ControllerClass = registry.getController(type);
+ const {datasetElementType, dataElementType} = defaults.datasets[type];
+ Object.assign(ControllerClass.prototype, {
+ dataElementType: registry.getElement(dataElementType),
+ datasetElementType: datasetElementType && registry.getElement(datasetElementType)
+ });
+ meta.controller = new ControllerClass(this, i);
+ newControllers.push(meta.controller);
+ }
+ }
+ this._updateMetasets();
+ return newControllers;
+ }
+ _resetElements() {
+ each(this.data.datasets, (dataset, datasetIndex) => {
+ this.getDatasetMeta(datasetIndex).controller.reset();
+ }, this);
+ }
+ reset() {
+ this._resetElements();
+ this.notifyPlugins('reset');
+ }
+ update(mode) {
+ const config = this.config;
+ config.update();
+ const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());
+ const animsDisabled = this._animationsDisabled = !options.animation;
+ this._updateScales();
+ this._checkEventBindings();
+ this._updateHiddenIndices();
+ this._plugins.invalidate();
+ if (this.notifyPlugins('beforeUpdate', {mode, cancelable: true}) === false) {
+ return;
+ }
+ const newControllers = this.buildOrUpdateControllers();
+ this.notifyPlugins('beforeElementsUpdate');
+ let minPadding = 0;
+ for (let i = 0, ilen = this.data.datasets.length; i < ilen; i++) {
+ const {controller} = this.getDatasetMeta(i);
+ const reset = !animsDisabled && newControllers.indexOf(controller) === -1;
+ controller.buildOrUpdateElements(reset);
+ minPadding = Math.max(+controller.getMaxOverflow(), minPadding);
+ }
+ minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;
+ this._updateLayout(minPadding);
+ if (!animsDisabled) {
+ each(newControllers, (controller) => {
+ controller.reset();
+ });
+ }
+ this._updateDatasets(mode);
+ this.notifyPlugins('afterUpdate', {mode});
+ this._layers.sort(compare2Level('z', '_idx'));
+ const {_active, _lastEvent} = this;
+ if (_lastEvent) {
+ this._eventHandler(_lastEvent, true);
+ } else if (_active.length) {
+ this._updateHoverStyles(_active, _active, true);
+ }
+ this.render();
+ }
+ _updateScales() {
+ each(this.scales, (scale) => {
+ layouts.removeBox(this, scale);
+ });
+ this.ensureScalesHaveIDs();
+ this.buildOrUpdateScales();
+ }
+ _checkEventBindings() {
+ const options = this.options;
+ const existingEvents = new Set(Object.keys(this._listeners));
+ const newEvents = new Set(options.events);
+ if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {
+ this.unbindEvents();
+ this.bindEvents();
+ }
+ }
+ _updateHiddenIndices() {
+ const {_hiddenIndices} = this;
+ const changes = this._getUniformDataChanges() || [];
+ for (const {method, start, count} of changes) {
+ const move = method === '_removeElements' ? -count : count;
+ moveNumericKeys(_hiddenIndices, start, move);
+ }
+ }
+ _getUniformDataChanges() {
+ const _dataChanges = this._dataChanges;
+ if (!_dataChanges || !_dataChanges.length) {
+ return;
+ }
+ this._dataChanges = [];
+ const datasetCount = this.data.datasets.length;
+ const makeSet = (idx) => new Set(
+ _dataChanges
+ .filter(c => c[0] === idx)
+ .map((c, i) => i + ',' + c.splice(1).join(','))
+ );
+ const changeSet = makeSet(0);
+ for (let i = 1; i < datasetCount; i++) {
+ if (!setsEqual(changeSet, makeSet(i))) {
+ return;
+ }
+ }
+ return Array.from(changeSet)
+ .map(c => c.split(','))
+ .map(a => ({method: a[1], start: +a[2], count: +a[3]}));
+ }
+ _updateLayout(minPadding) {
+ if (this.notifyPlugins('beforeLayout', {cancelable: true}) === false) {
+ return;
+ }
+ layouts.update(this, this.width, this.height, minPadding);
+ const area = this.chartArea;
+ const noArea = area.width <= 0 || area.height <= 0;
+ this._layers = [];
+ each(this.boxes, (box) => {
+ if (noArea && box.position === 'chartArea') {
+ return;
+ }
+ if (box.configure) {
+ box.configure();
+ }
+ this._layers.push(...box._layers());
+ }, this);
+ this._layers.forEach((item, index) => {
+ item._idx = index;
+ });
+ this.notifyPlugins('afterLayout');
+ }
+ _updateDatasets(mode) {
+ if (this.notifyPlugins('beforeDatasetsUpdate', {mode, cancelable: true}) === false) {
+ return;
+ }
+ for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
+ this.getDatasetMeta(i).controller.configure();
+ }
+ for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
+ this._updateDataset(i, isFunction(mode) ? mode({datasetIndex: i}) : mode);
+ }
+ this.notifyPlugins('afterDatasetsUpdate', {mode});
+ }
+ _updateDataset(index, mode) {
+ const meta = this.getDatasetMeta(index);
+ const args = {meta, index, mode, cancelable: true};
+ if (this.notifyPlugins('beforeDatasetUpdate', args) === false) {
+ return;
+ }
+ meta.controller._update(mode);
+ args.cancelable = false;
+ this.notifyPlugins('afterDatasetUpdate', args);
+ }
+ render() {
+ if (this.notifyPlugins('beforeRender', {cancelable: true}) === false) {
+ return;
+ }
+ if (animator.has(this)) {
+ if (this.attached && !animator.running(this)) {
+ animator.start(this);
+ }
+ } else {
+ this.draw();
+ onAnimationsComplete({chart: this});
+ }
+ }
+ draw() {
+ let i;
+ if (this._resizeBeforeDraw) {
+ const {width, height} = this._resizeBeforeDraw;
+ this._resize(width, height);
+ this._resizeBeforeDraw = null;
+ }
+ this.clear();
+ if (this.width <= 0 || this.height <= 0) {
+ return;
+ }
+ if (this.notifyPlugins('beforeDraw', {cancelable: true}) === false) {
+ return;
+ }
+ const layers = this._layers;
+ for (i = 0; i < layers.length && layers[i].z <= 0; ++i) {
+ layers[i].draw(this.chartArea);
+ }
+ this._drawDatasets();
+ for (; i < layers.length; ++i) {
+ layers[i].draw(this.chartArea);
+ }
+ this.notifyPlugins('afterDraw');
+ }
+ _getSortedDatasetMetas(filterVisible) {
+ const metasets = this._sortedMetasets;
+ const result = [];
+ let i, ilen;
+ for (i = 0, ilen = metasets.length; i < ilen; ++i) {
+ const meta = metasets[i];
+ if (!filterVisible || meta.visible) {
+ result.push(meta);
+ }
+ }
+ return result;
+ }
+ getSortedVisibleDatasetMetas() {
+ return this._getSortedDatasetMetas(true);
+ }
+ _drawDatasets() {
+ if (this.notifyPlugins('beforeDatasetsDraw', {cancelable: true}) === false) {
+ return;
+ }
+ const metasets = this.getSortedVisibleDatasetMetas();
+ for (let i = metasets.length - 1; i >= 0; --i) {
+ this._drawDataset(metasets[i]);
+ }
+ this.notifyPlugins('afterDatasetsDraw');
+ }
+ _drawDataset(meta) {
+ const ctx = this.ctx;
+ const clip = meta._clip;
+ const useClip = !clip.disabled;
+ const area = this.chartArea;
+ const args = {
+ meta,
+ index: meta.index,
+ cancelable: true
+ };
+ if (this.notifyPlugins('beforeDatasetDraw', args) === false) {
+ return;
+ }
+ if (useClip) {
+ clipArea(ctx, {
+ left: clip.left === false ? 0 : area.left - clip.left,
+ right: clip.right === false ? this.width : area.right + clip.right,
+ top: clip.top === false ? 0 : area.top - clip.top,
+ bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom
+ });
+ }
+ meta.controller.draw();
+ if (useClip) {
+ unclipArea(ctx);
+ }
+ args.cancelable = false;
+ this.notifyPlugins('afterDatasetDraw', args);
+ }
+ getElementsAtEventForMode(e, mode, options, useFinalPosition) {
+ const method = Interaction.modes[mode];
+ if (typeof method === 'function') {
+ return method(this, e, options, useFinalPosition);
+ }
+ return [];
+ }
+ getDatasetMeta(datasetIndex) {
+ const dataset = this.data.datasets[datasetIndex];
+ const metasets = this._metasets;
+ let meta = metasets.filter(x => x && x._dataset === dataset).pop();
+ if (!meta) {
+ meta = {
+ type: null,
+ data: [],
+ dataset: null,
+ controller: null,
+ hidden: null,
+ xAxisID: null,
+ yAxisID: null,
+ order: dataset && dataset.order || 0,
+ index: datasetIndex,
+ _dataset: dataset,
+ _parsed: [],
+ _sorted: false
+ };
+ metasets.push(meta);
+ }
+ return meta;
+ }
+ getContext() {
+ return this.$context || (this.$context = createContext(null, {chart: this, type: 'chart'}));
+ }
+ getVisibleDatasetCount() {
+ return this.getSortedVisibleDatasetMetas().length;
+ }
+ isDatasetVisible(datasetIndex) {
+ const dataset = this.data.datasets[datasetIndex];
+ if (!dataset) {
+ return false;
+ }
+ const meta = this.getDatasetMeta(datasetIndex);
+ return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden;
+ }
+ setDatasetVisibility(datasetIndex, visible) {
+ const meta = this.getDatasetMeta(datasetIndex);
+ meta.hidden = !visible;
+ }
+ toggleDataVisibility(index) {
+ this._hiddenIndices[index] = !this._hiddenIndices[index];
+ }
+ getDataVisibility(index) {
+ return !this._hiddenIndices[index];
+ }
+ _updateVisibility(datasetIndex, dataIndex, visible) {
+ const mode = visible ? 'show' : 'hide';
+ const meta = this.getDatasetMeta(datasetIndex);
+ const anims = meta.controller._resolveAnimations(undefined, mode);
+ if (defined(dataIndex)) {
+ meta.data[dataIndex].hidden = !visible;
+ this.update();
+ } else {
+ this.setDatasetVisibility(datasetIndex, visible);
+ anims.update(meta, {visible});
+ this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : undefined);
+ }
+ }
+ hide(datasetIndex, dataIndex) {
+ this._updateVisibility(datasetIndex, dataIndex, false);
+ }
+ show(datasetIndex, dataIndex) {
+ this._updateVisibility(datasetIndex, dataIndex, true);
+ }
+ _destroyDatasetMeta(datasetIndex) {
+ const meta = this._metasets[datasetIndex];
+ if (meta && meta.controller) {
+ meta.controller._destroy();
+ }
+ delete this._metasets[datasetIndex];
+ }
+ _stop() {
+ let i, ilen;
+ this.stop();
+ animator.remove(this);
+ for (i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
+ this._destroyDatasetMeta(i);
+ }
+ }
+ destroy() {
+ this.notifyPlugins('beforeDestroy');
+ const {canvas, ctx} = this;
+ this._stop();
+ this.config.clearCache();
+ if (canvas) {
+ this.unbindEvents();
+ clearCanvas(canvas, ctx);
+ this.platform.releaseContext(ctx);
+ this.canvas = null;
+ this.ctx = null;
+ }
+ this.notifyPlugins('destroy');
+ delete instances[this.id];
+ this.notifyPlugins('afterDestroy');
+ }
+ toBase64Image(...args) {
+ return this.canvas.toDataURL(...args);
+ }
+ bindEvents() {
+ this.bindUserEvents();
+ if (this.options.responsive) {
+ this.bindResponsiveEvents();
+ } else {
+ this.attached = true;
+ }
+ }
+ bindUserEvents() {
+ const listeners = this._listeners;
+ const platform = this.platform;
+ const _add = (type, listener) => {
+ platform.addEventListener(this, type, listener);
+ listeners[type] = listener;
+ };
+ const listener = (e, x, y) => {
+ e.offsetX = x;
+ e.offsetY = y;
+ this._eventHandler(e);
+ };
+ each(this.options.events, (type) => _add(type, listener));
+ }
+ bindResponsiveEvents() {
+ if (!this._responsiveListeners) {
+ this._responsiveListeners = {};
+ }
+ const listeners = this._responsiveListeners;
+ const platform = this.platform;
+ const _add = (type, listener) => {
+ platform.addEventListener(this, type, listener);
+ listeners[type] = listener;
+ };
+ const _remove = (type, listener) => {
+ if (listeners[type]) {
+ platform.removeEventListener(this, type, listener);
+ delete listeners[type];
+ }
+ };
+ const listener = (width, height) => {
+ if (this.canvas) {
+ this.resize(width, height);
+ }
+ };
+ let detached;
+ const attached = () => {
+ _remove('attach', attached);
+ this.attached = true;
+ this.resize();
+ _add('resize', listener);
+ _add('detach', detached);
+ };
+ detached = () => {
+ this.attached = false;
+ _remove('resize', listener);
+ this._stop();
+ this._resize(0, 0);
+ _add('attach', attached);
+ };
+ if (platform.isAttached(this.canvas)) {
+ attached();
+ } else {
+ detached();
+ }
+ }
+ unbindEvents() {
+ each(this._listeners, (listener, type) => {
+ this.platform.removeEventListener(this, type, listener);
+ });
+ this._listeners = {};
+ each(this._responsiveListeners, (listener, type) => {
+ this.platform.removeEventListener(this, type, listener);
+ });
+ this._responsiveListeners = undefined;
+ }
+ updateHoverStyle(items, mode, enabled) {
+ const prefix = enabled ? 'set' : 'remove';
+ let meta, item, i, ilen;
+ if (mode === 'dataset') {
+ meta = this.getDatasetMeta(items[0].datasetIndex);
+ meta.controller['_' + prefix + 'DatasetHoverStyle']();
+ }
+ for (i = 0, ilen = items.length; i < ilen; ++i) {
+ item = items[i];
+ const controller = item && this.getDatasetMeta(item.datasetIndex).controller;
+ if (controller) {
+ controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index);
+ }
+ }
+ }
+ getActiveElements() {
+ return this._active || [];
+ }
+ setActiveElements(activeElements) {
+ const lastActive = this._active || [];
+ const active = activeElements.map(({datasetIndex, index}) => {
+ const meta = this.getDatasetMeta(datasetIndex);
+ if (!meta) {
+ throw new Error('No dataset found at index ' + datasetIndex);
+ }
+ return {
+ datasetIndex,
+ element: meta.data[index],
+ index,
+ };
+ });
+ const changed = !_elementsEqual(active, lastActive);
+ if (changed) {
+ this._active = active;
+ this._lastEvent = null;
+ this._updateHoverStyles(active, lastActive);
+ }
+ }
+ notifyPlugins(hook, args, filter) {
+ return this._plugins.notify(this, hook, args, filter);
+ }
+ _updateHoverStyles(active, lastActive, replay) {
+ const hoverOptions = this.options.hover;
+ const diff = (a, b) => a.filter(x => !b.some(y => x.datasetIndex === y.datasetIndex && x.index === y.index));
+ const deactivated = diff(lastActive, active);
+ const activated = replay ? active : diff(active, lastActive);
+ if (deactivated.length) {
+ this.updateHoverStyle(deactivated, hoverOptions.mode, false);
+ }
+ if (activated.length && hoverOptions.mode) {
+ this.updateHoverStyle(activated, hoverOptions.mode, true);
+ }
+ }
+ _eventHandler(e, replay) {
+ const args = {
+ event: e,
+ replay,
+ cancelable: true,
+ inChartArea: _isPointInArea(e, this.chartArea, this._minPadding)
+ };
+ const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type);
+ if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) {
+ return;
+ }
+ const changed = this._handleEvent(e, replay, args.inChartArea);
+ args.cancelable = false;
+ this.notifyPlugins('afterEvent', args, eventFilter);
+ if (changed || args.changed) {
+ this.render();
+ }
+ return this;
+ }
+ _handleEvent(e, replay, inChartArea) {
+ const {_active: lastActive = [], options} = this;
+ const useFinalPosition = replay;
+ const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition);
+ const isClick = _isClickEvent(e);
+ const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick);
+ if (inChartArea) {
+ this._lastEvent = null;
+ callback(options.onHover, [e, active, this], this);
+ if (isClick) {
+ callback(options.onClick, [e, active, this], this);
+ }
+ }
+ const changed = !_elementsEqual(active, lastActive);
+ if (changed || replay) {
+ this._active = active;
+ this._updateHoverStyles(active, lastActive, replay);
+ }
+ this._lastEvent = lastEvent;
+ return changed;
+ }
+ _getActiveElements(e, lastActive, inChartArea, useFinalPosition) {
+ if (e.type === 'mouseout') {
+ return [];
+ }
+ if (!inChartArea) {
+ return lastActive;
+ }
+ const hoverOptions = this.options.hover;
+ return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);
+ }
+}
+const invalidatePlugins = () => each(Chart.instances, (chart) => chart._plugins.invalidate());
+const enumerable = true;
+Object.defineProperties(Chart, {
+ defaults: {
+ enumerable,
+ value: defaults
+ },
+ instances: {
+ enumerable,
+ value: instances
+ },
+ overrides: {
+ enumerable,
+ value: overrides
+ },
+ registry: {
+ enumerable,
+ value: registry
+ },
+ version: {
+ enumerable,
+ value: version
+ },
+ getChart: {
+ enumerable,
+ value: getChart
+ },
+ register: {
+ enumerable,
+ value: (...items) => {
+ registry.add(...items);
+ invalidatePlugins();
+ }
+ },
+ unregister: {
+ enumerable,
+ value: (...items) => {
+ registry.remove(...items);
+ invalidatePlugins();
+ }
+ }
+});
+
+function abstract() {
+ throw new Error('This method is not implemented: Check that a complete date adapter is provided.');
+}
+class DateAdapter {
+ constructor(options) {
+ this.options = options || {};
+ }
+ formats() {
+ return abstract();
+ }
+ parse(value, format) {
+ return abstract();
+ }
+ format(timestamp, format) {
+ return abstract();
+ }
+ add(timestamp, amount, unit) {
+ return abstract();
+ }
+ diff(a, b, unit) {
+ return abstract();
+ }
+ startOf(timestamp, unit, weekday) {
+ return abstract();
+ }
+ endOf(timestamp, unit) {
+ return abstract();
+ }
+}
+DateAdapter.override = function(members) {
+ Object.assign(DateAdapter.prototype, members);
+};
+var _adapters = {
+ _date: DateAdapter
+};
+
+function getAllScaleValues(scale, type) {
+ if (!scale._cache.$bar) {
+ const visibleMetas = scale.getMatchingVisibleMetas(type);
+ let values = [];
+ for (let i = 0, ilen = visibleMetas.length; i < ilen; i++) {
+ values = values.concat(visibleMetas[i].controller.getAllParsedValues(scale));
+ }
+ scale._cache.$bar = _arrayUnique(values.sort((a, b) => a - b));
+ }
+ return scale._cache.$bar;
+}
+function computeMinSampleSize(meta) {
+ const scale = meta.iScale;
+ const values = getAllScaleValues(scale, meta.type);
+ let min = scale._length;
+ let i, ilen, curr, prev;
+ const updateMinAndPrev = () => {
+ if (curr === 32767 || curr === -32768) {
+ return;
+ }
+ if (defined(prev)) {
+ min = Math.min(min, Math.abs(curr - prev) || min);
+ }
+ prev = curr;
+ };
+ for (i = 0, ilen = values.length; i < ilen; ++i) {
+ curr = scale.getPixelForValue(values[i]);
+ updateMinAndPrev();
+ }
+ prev = undefined;
+ for (i = 0, ilen = scale.ticks.length; i < ilen; ++i) {
+ curr = scale.getPixelForTick(i);
+ updateMinAndPrev();
+ }
+ return min;
+}
+function computeFitCategoryTraits(index, ruler, options, stackCount) {
+ const thickness = options.barThickness;
+ let size, ratio;
+ if (isNullOrUndef(thickness)) {
+ size = ruler.min * options.categoryPercentage;
+ ratio = options.barPercentage;
+ } else {
+ size = thickness * stackCount;
+ ratio = 1;
+ }
+ return {
+ chunk: size / stackCount,
+ ratio,
+ start: ruler.pixels[index] - (size / 2)
+ };
+}
+function computeFlexCategoryTraits(index, ruler, options, stackCount) {
+ const pixels = ruler.pixels;
+ const curr = pixels[index];
+ let prev = index > 0 ? pixels[index - 1] : null;
+ let next = index < pixels.length - 1 ? pixels[index + 1] : null;
+ const percent = options.categoryPercentage;
+ if (prev === null) {
+ prev = curr - (next === null ? ruler.end - ruler.start : next - curr);
+ }
+ if (next === null) {
+ next = curr + curr - prev;
+ }
+ const start = curr - (curr - Math.min(prev, next)) / 2 * percent;
+ const size = Math.abs(next - prev) / 2 * percent;
+ return {
+ chunk: size / stackCount,
+ ratio: options.barPercentage,
+ start
+ };
+}
+function parseFloatBar(entry, item, vScale, i) {
+ const startValue = vScale.parse(entry[0], i);
+ const endValue = vScale.parse(entry[1], i);
+ const min = Math.min(startValue, endValue);
+ const max = Math.max(startValue, endValue);
+ let barStart = min;
+ let barEnd = max;
+ if (Math.abs(min) > Math.abs(max)) {
+ barStart = max;
+ barEnd = min;
+ }
+ item[vScale.axis] = barEnd;
+ item._custom = {
+ barStart,
+ barEnd,
+ start: startValue,
+ end: endValue,
+ min,
+ max
+ };
+}
+function parseValue(entry, item, vScale, i) {
+ if (isArray(entry)) {
+ parseFloatBar(entry, item, vScale, i);
+ } else {
+ item[vScale.axis] = vScale.parse(entry, i);
+ }
+ return item;
+}
+function parseArrayOrPrimitive(meta, data, start, count) {
+ const iScale = meta.iScale;
+ const vScale = meta.vScale;
+ const labels = iScale.getLabels();
+ const singleScale = iScale === vScale;
+ const parsed = [];
+ let i, ilen, item, entry;
+ for (i = start, ilen = start + count; i < ilen; ++i) {
+ entry = data[i];
+ item = {};
+ item[iScale.axis] = singleScale || iScale.parse(labels[i], i);
+ parsed.push(parseValue(entry, item, vScale, i));
+ }
+ return parsed;
+}
+function isFloatBar(custom) {
+ return custom && custom.barStart !== undefined && custom.barEnd !== undefined;
+}
+function barSign(size, vScale, actualBase) {
+ if (size !== 0) {
+ return sign(size);
+ }
+ return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1);
+}
+function borderProps(properties) {
+ let reverse, start, end, top, bottom;
+ if (properties.horizontal) {
+ reverse = properties.base > properties.x;
+ start = 'left';
+ end = 'right';
+ } else {
+ reverse = properties.base < properties.y;
+ start = 'bottom';
+ end = 'top';
+ }
+ if (reverse) {
+ top = 'end';
+ bottom = 'start';
+ } else {
+ top = 'start';
+ bottom = 'end';
+ }
+ return {start, end, reverse, top, bottom};
+}
+function setBorderSkipped(properties, options, stack, index) {
+ let edge = options.borderSkipped;
+ const res = {};
+ if (!edge) {
+ properties.borderSkipped = res;
+ return;
+ }
+ const {start, end, reverse, top, bottom} = borderProps(properties);
+ if (edge === 'middle' && stack) {
+ properties.enableBorderRadius = true;
+ if ((stack._top || 0) === index) {
+ edge = top;
+ } else if ((stack._bottom || 0) === index) {
+ edge = bottom;
+ } else {
+ res[parseEdge(bottom, start, end, reverse)] = true;
+ edge = top;
+ }
+ }
+ res[parseEdge(edge, start, end, reverse)] = true;
+ properties.borderSkipped = res;
+}
+function parseEdge(edge, a, b, reverse) {
+ if (reverse) {
+ edge = swap(edge, a, b);
+ edge = startEnd(edge, b, a);
+ } else {
+ edge = startEnd(edge, a, b);
+ }
+ return edge;
+}
+function swap(orig, v1, v2) {
+ return orig === v1 ? v2 : orig === v2 ? v1 : orig;
+}
+function startEnd(v, start, end) {
+ return v === 'start' ? start : v === 'end' ? end : v;
+}
+function setInflateAmount(properties, {inflateAmount}, ratio) {
+ properties.inflateAmount = inflateAmount === 'auto'
+ ? ratio === 1 ? 0.33 : 0
+ : inflateAmount;
+}
+class BarController extends DatasetController {
+ parsePrimitiveData(meta, data, start, count) {
+ return parseArrayOrPrimitive(meta, data, start, count);
+ }
+ parseArrayData(meta, data, start, count) {
+ return parseArrayOrPrimitive(meta, data, start, count);
+ }
+ parseObjectData(meta, data, start, count) {
+ const {iScale, vScale} = meta;
+ const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;
+ const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey;
+ const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey;
+ const parsed = [];
+ let i, ilen, item, obj;
+ for (i = start, ilen = start + count; i < ilen; ++i) {
+ obj = data[i];
+ item = {};
+ item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i);
+ parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i));
+ }
+ return parsed;
+ }
+ updateRangeFromParsed(range, scale, parsed, stack) {
+ super.updateRangeFromParsed(range, scale, parsed, stack);
+ const custom = parsed._custom;
+ if (custom && scale === this._cachedMeta.vScale) {
+ range.min = Math.min(range.min, custom.min);
+ range.max = Math.max(range.max, custom.max);
+ }
+ }
+ getMaxOverflow() {
+ return 0;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const {iScale, vScale} = meta;
+ const parsed = this.getParsed(index);
+ const custom = parsed._custom;
+ const value = isFloatBar(custom)
+ ? '[' + custom.start + ', ' + custom.end + ']'
+ : '' + vScale.getLabelForValue(parsed[vScale.axis]);
+ return {
+ label: '' + iScale.getLabelForValue(parsed[iScale.axis]),
+ value
+ };
+ }
+ initialize() {
+ this.enableOptionSharing = true;
+ super.initialize();
+ const meta = this._cachedMeta;
+ meta.stack = this.getDataset().stack;
+ }
+ update(mode) {
+ const meta = this._cachedMeta;
+ this.updateElements(meta.data, 0, meta.data.length, mode);
+ }
+ updateElements(bars, start, count, mode) {
+ const reset = mode === 'reset';
+ const {index, _cachedMeta: {vScale}} = this;
+ const base = vScale.getBasePixel();
+ const horizontal = vScale.isHorizontal();
+ const ruler = this._getRuler();
+ const firstOpts = this.resolveDataElementOptions(start, mode);
+ const sharedOptions = this.getSharedOptions(firstOpts);
+ const includeOptions = this.includeOptions(mode, sharedOptions);
+ this.updateSharedOptions(sharedOptions, mode, firstOpts);
+ for (let i = start; i < start + count; i++) {
+ const parsed = this.getParsed(i);
+ const vpixels = reset || isNullOrUndef(parsed[vScale.axis]) ? {base, head: base} : this._calculateBarValuePixels(i);
+ const ipixels = this._calculateBarIndexPixels(i, ruler);
+ const stack = (parsed._stacks || {})[vScale.axis];
+ const properties = {
+ horizontal,
+ base: vpixels.base,
+ enableBorderRadius: !stack || isFloatBar(parsed._custom) || (index === stack._top || index === stack._bottom),
+ x: horizontal ? vpixels.head : ipixels.center,
+ y: horizontal ? ipixels.center : vpixels.head,
+ height: horizontal ? ipixels.size : Math.abs(vpixels.size),
+ width: horizontal ? Math.abs(vpixels.size) : ipixels.size
+ };
+ if (includeOptions) {
+ properties.options = sharedOptions || this.resolveDataElementOptions(i, bars[i].active ? 'active' : mode);
+ }
+ const options = properties.options || bars[i].options;
+ setBorderSkipped(properties, options, stack, index);
+ setInflateAmount(properties, options, ruler.ratio);
+ this.updateElement(bars[i], i, properties, mode);
+ }
+ }
+ _getStacks(last, dataIndex) {
+ const meta = this._cachedMeta;
+ const iScale = meta.iScale;
+ const metasets = iScale.getMatchingVisibleMetas(this._type);
+ const stacked = iScale.options.stacked;
+ const ilen = metasets.length;
+ const stacks = [];
+ let i, item;
+ for (i = 0; i < ilen; ++i) {
+ item = metasets[i];
+ if (!item.controller.options.grouped) {
+ continue;
+ }
+ if (typeof dataIndex !== 'undefined') {
+ const val = item.controller.getParsed(dataIndex)[
+ item.controller._cachedMeta.vScale.axis
+ ];
+ if (isNullOrUndef(val) || isNaN(val)) {
+ continue;
+ }
+ }
+ if (stacked === false || stacks.indexOf(item.stack) === -1 ||
+ (stacked === undefined && item.stack === undefined)) {
+ stacks.push(item.stack);
+ }
+ if (item.index === last) {
+ break;
+ }
+ }
+ if (!stacks.length) {
+ stacks.push(undefined);
+ }
+ return stacks;
+ }
+ _getStackCount(index) {
+ return this._getStacks(undefined, index).length;
+ }
+ _getStackIndex(datasetIndex, name, dataIndex) {
+ const stacks = this._getStacks(datasetIndex, dataIndex);
+ const index = (name !== undefined)
+ ? stacks.indexOf(name)
+ : -1;
+ return (index === -1)
+ ? stacks.length - 1
+ : index;
+ }
+ _getRuler() {
+ const opts = this.options;
+ const meta = this._cachedMeta;
+ const iScale = meta.iScale;
+ const pixels = [];
+ let i, ilen;
+ for (i = 0, ilen = meta.data.length; i < ilen; ++i) {
+ pixels.push(iScale.getPixelForValue(this.getParsed(i)[iScale.axis], i));
+ }
+ const barThickness = opts.barThickness;
+ const min = barThickness || computeMinSampleSize(meta);
+ return {
+ min,
+ pixels,
+ start: iScale._startPixel,
+ end: iScale._endPixel,
+ stackCount: this._getStackCount(),
+ scale: iScale,
+ grouped: opts.grouped,
+ ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage
+ };
+ }
+ _calculateBarValuePixels(index) {
+ const {_cachedMeta: {vScale, _stacked}, options: {base: baseValue, minBarLength}} = this;
+ const actualBase = baseValue || 0;
+ const parsed = this.getParsed(index);
+ const custom = parsed._custom;
+ const floating = isFloatBar(custom);
+ let value = parsed[vScale.axis];
+ let start = 0;
+ let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value;
+ let head, size;
+ if (length !== value) {
+ start = length - value;
+ length = value;
+ }
+ if (floating) {
+ value = custom.barStart;
+ length = custom.barEnd - custom.barStart;
+ if (value !== 0 && sign(value) !== sign(custom.barEnd)) {
+ start = 0;
+ }
+ start += value;
+ }
+ const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start;
+ let base = vScale.getPixelForValue(startValue);
+ if (this.chart.getDataVisibility(index)) {
+ head = vScale.getPixelForValue(start + length);
+ } else {
+ head = base;
+ }
+ size = head - base;
+ if (Math.abs(size) < minBarLength) {
+ size = barSign(size, vScale, actualBase) * minBarLength;
+ if (value === actualBase) {
+ base -= size / 2;
+ }
+ head = base + size;
+ }
+ if (base === vScale.getPixelForValue(actualBase)) {
+ const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2;
+ base += halfGrid;
+ size -= halfGrid;
+ }
+ return {
+ size,
+ base,
+ head,
+ center: head + size / 2
+ };
+ }
+ _calculateBarIndexPixels(index, ruler) {
+ const scale = ruler.scale;
+ const options = this.options;
+ const skipNull = options.skipNull;
+ const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity);
+ let center, size;
+ if (ruler.grouped) {
+ const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount;
+ const range = options.barThickness === 'flex'
+ ? computeFlexCategoryTraits(index, ruler, options, stackCount)
+ : computeFitCategoryTraits(index, ruler, options, stackCount);
+ const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : undefined);
+ center = range.start + (range.chunk * stackIndex) + (range.chunk / 2);
+ size = Math.min(maxBarThickness, range.chunk * range.ratio);
+ } else {
+ center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index);
+ size = Math.min(maxBarThickness, ruler.min * ruler.ratio);
+ }
+ return {
+ base: center - size / 2,
+ head: center + size / 2,
+ center,
+ size
+ };
+ }
+ draw() {
+ const meta = this._cachedMeta;
+ const vScale = meta.vScale;
+ const rects = meta.data;
+ const ilen = rects.length;
+ let i = 0;
+ for (; i < ilen; ++i) {
+ if (this.getParsed(i)[vScale.axis] !== null) {
+ rects[i].draw(this._ctx);
+ }
+ }
+ }
+}
+BarController.id = 'bar';
+BarController.defaults = {
+ datasetElementType: false,
+ dataElementType: 'bar',
+ categoryPercentage: 0.8,
+ barPercentage: 0.9,
+ grouped: true,
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: ['x', 'y', 'base', 'width', 'height']
+ }
+ }
+};
+BarController.overrides = {
+ scales: {
+ _index_: {
+ type: 'category',
+ offset: true,
+ grid: {
+ offset: true
+ }
+ },
+ _value_: {
+ type: 'linear',
+ beginAtZero: true,
+ }
+ }
+};
+
+class BubbleController extends DatasetController {
+ initialize() {
+ this.enableOptionSharing = true;
+ super.initialize();
+ }
+ parsePrimitiveData(meta, data, start, count) {
+ const parsed = super.parsePrimitiveData(meta, data, start, count);
+ for (let i = 0; i < parsed.length; i++) {
+ parsed[i]._custom = this.resolveDataElementOptions(i + start).radius;
+ }
+ return parsed;
+ }
+ parseArrayData(meta, data, start, count) {
+ const parsed = super.parseArrayData(meta, data, start, count);
+ for (let i = 0; i < parsed.length; i++) {
+ const item = data[start + i];
+ parsed[i]._custom = valueOrDefault(item[2], this.resolveDataElementOptions(i + start).radius);
+ }
+ return parsed;
+ }
+ parseObjectData(meta, data, start, count) {
+ const parsed = super.parseObjectData(meta, data, start, count);
+ for (let i = 0; i < parsed.length; i++) {
+ const item = data[start + i];
+ parsed[i]._custom = valueOrDefault(item && item.r && +item.r, this.resolveDataElementOptions(i + start).radius);
+ }
+ return parsed;
+ }
+ getMaxOverflow() {
+ const data = this._cachedMeta.data;
+ let max = 0;
+ for (let i = data.length - 1; i >= 0; --i) {
+ max = Math.max(max, data[i].size(this.resolveDataElementOptions(i)) / 2);
+ }
+ return max > 0 && max;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const {xScale, yScale} = meta;
+ const parsed = this.getParsed(index);
+ const x = xScale.getLabelForValue(parsed.x);
+ const y = yScale.getLabelForValue(parsed.y);
+ const r = parsed._custom;
+ return {
+ label: meta.label,
+ value: '(' + x + ', ' + y + (r ? ', ' + r : '') + ')'
+ };
+ }
+ update(mode) {
+ const points = this._cachedMeta.data;
+ this.updateElements(points, 0, points.length, mode);
+ }
+ updateElements(points, start, count, mode) {
+ const reset = mode === 'reset';
+ const {iScale, vScale} = this._cachedMeta;
+ const firstOpts = this.resolveDataElementOptions(start, mode);
+ const sharedOptions = this.getSharedOptions(firstOpts);
+ const includeOptions = this.includeOptions(mode, sharedOptions);
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ for (let i = start; i < start + count; i++) {
+ const point = points[i];
+ const parsed = !reset && this.getParsed(i);
+ const properties = {};
+ const iPixel = properties[iAxis] = reset ? iScale.getPixelForDecimal(0.5) : iScale.getPixelForValue(parsed[iAxis]);
+ const vPixel = properties[vAxis] = reset ? vScale.getBasePixel() : vScale.getPixelForValue(parsed[vAxis]);
+ properties.skip = isNaN(iPixel) || isNaN(vPixel);
+ if (includeOptions) {
+ properties.options = this.resolveDataElementOptions(i, point.active ? 'active' : mode);
+ if (reset) {
+ properties.options.radius = 0;
+ }
+ }
+ this.updateElement(point, i, properties, mode);
+ }
+ this.updateSharedOptions(sharedOptions, mode, firstOpts);
+ }
+ resolveDataElementOptions(index, mode) {
+ const parsed = this.getParsed(index);
+ let values = super.resolveDataElementOptions(index, mode);
+ if (values.$shared) {
+ values = Object.assign({}, values, {$shared: false});
+ }
+ const radius = values.radius;
+ if (mode !== 'active') {
+ values.radius = 0;
+ }
+ values.radius += valueOrDefault(parsed && parsed._custom, radius);
+ return values;
+ }
+}
+BubbleController.id = 'bubble';
+BubbleController.defaults = {
+ datasetElementType: false,
+ dataElementType: 'point',
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: ['x', 'y', 'borderWidth', 'radius']
+ }
+ }
+};
+BubbleController.overrides = {
+ scales: {
+ x: {
+ type: 'linear'
+ },
+ y: {
+ type: 'linear'
+ }
+ },
+ plugins: {
+ tooltip: {
+ callbacks: {
+ title() {
+ return '';
+ }
+ }
+ }
+ }
+};
+
+function getRatioAndOffset(rotation, circumference, cutout) {
+ let ratioX = 1;
+ let ratioY = 1;
+ let offsetX = 0;
+ let offsetY = 0;
+ if (circumference < TAU) {
+ const startAngle = rotation;
+ const endAngle = startAngle + circumference;
+ const startX = Math.cos(startAngle);
+ const startY = Math.sin(startAngle);
+ const endX = Math.cos(endAngle);
+ const endY = Math.sin(endAngle);
+ const calcMax = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a, a * cutout, b, b * cutout);
+ const calcMin = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a, a * cutout, b, b * cutout);
+ const maxX = calcMax(0, startX, endX);
+ const maxY = calcMax(HALF_PI, startY, endY);
+ const minX = calcMin(PI, startX, endX);
+ const minY = calcMin(PI + HALF_PI, startY, endY);
+ ratioX = (maxX - minX) / 2;
+ ratioY = (maxY - minY) / 2;
+ offsetX = -(maxX + minX) / 2;
+ offsetY = -(maxY + minY) / 2;
+ }
+ return {ratioX, ratioY, offsetX, offsetY};
+}
+class DoughnutController extends DatasetController {
+ constructor(chart, datasetIndex) {
+ super(chart, datasetIndex);
+ this.enableOptionSharing = true;
+ this.innerRadius = undefined;
+ this.outerRadius = undefined;
+ this.offsetX = undefined;
+ this.offsetY = undefined;
+ }
+ linkScales() {}
+ parse(start, count) {
+ const data = this.getDataset().data;
+ const meta = this._cachedMeta;
+ if (this._parsing === false) {
+ meta._parsed = data;
+ } else {
+ let getter = (i) => +data[i];
+ if (isObject(data[start])) {
+ const {key = 'value'} = this._parsing;
+ getter = (i) => +resolveObjectKey(data[i], key);
+ }
+ let i, ilen;
+ for (i = start, ilen = start + count; i < ilen; ++i) {
+ meta._parsed[i] = getter(i);
+ }
+ }
+ }
+ _getRotation() {
+ return toRadians(this.options.rotation - 90);
+ }
+ _getCircumference() {
+ return toRadians(this.options.circumference);
+ }
+ _getRotationExtents() {
+ let min = TAU;
+ let max = -TAU;
+ for (let i = 0; i < this.chart.data.datasets.length; ++i) {
+ if (this.chart.isDatasetVisible(i)) {
+ const controller = this.chart.getDatasetMeta(i).controller;
+ const rotation = controller._getRotation();
+ const circumference = controller._getCircumference();
+ min = Math.min(min, rotation);
+ max = Math.max(max, rotation + circumference);
+ }
+ }
+ return {
+ rotation: min,
+ circumference: max - min,
+ };
+ }
+ update(mode) {
+ const chart = this.chart;
+ const {chartArea} = chart;
+ const meta = this._cachedMeta;
+ const arcs = meta.data;
+ const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing;
+ const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0);
+ const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1);
+ const chartWeight = this._getRingWeight(this.index);
+ const {circumference, rotation} = this._getRotationExtents();
+ const {ratioX, ratioY, offsetX, offsetY} = getRatioAndOffset(rotation, circumference, cutout);
+ const maxWidth = (chartArea.width - spacing) / ratioX;
+ const maxHeight = (chartArea.height - spacing) / ratioY;
+ const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);
+ const outerRadius = toDimension(this.options.radius, maxRadius);
+ const innerRadius = Math.max(outerRadius * cutout, 0);
+ const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal();
+ this.offsetX = offsetX * outerRadius;
+ this.offsetY = offsetY * outerRadius;
+ meta.total = this.calculateTotal();
+ this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index);
+ this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0);
+ this.updateElements(arcs, 0, arcs.length, mode);
+ }
+ _circumference(i, reset) {
+ const opts = this.options;
+ const meta = this._cachedMeta;
+ const circumference = this._getCircumference();
+ if ((reset && opts.animation.animateRotate) || !this.chart.getDataVisibility(i) || meta._parsed[i] === null || meta.data[i].hidden) {
+ return 0;
+ }
+ return this.calculateCircumference(meta._parsed[i] * circumference / TAU);
+ }
+ updateElements(arcs, start, count, mode) {
+ const reset = mode === 'reset';
+ const chart = this.chart;
+ const chartArea = chart.chartArea;
+ const opts = chart.options;
+ const animationOpts = opts.animation;
+ const centerX = (chartArea.left + chartArea.right) / 2;
+ const centerY = (chartArea.top + chartArea.bottom) / 2;
+ const animateScale = reset && animationOpts.animateScale;
+ const innerRadius = animateScale ? 0 : this.innerRadius;
+ const outerRadius = animateScale ? 0 : this.outerRadius;
+ const firstOpts = this.resolveDataElementOptions(start, mode);
+ const sharedOptions = this.getSharedOptions(firstOpts);
+ const includeOptions = this.includeOptions(mode, sharedOptions);
+ let startAngle = this._getRotation();
+ let i;
+ for (i = 0; i < start; ++i) {
+ startAngle += this._circumference(i, reset);
+ }
+ for (i = start; i < start + count; ++i) {
+ const circumference = this._circumference(i, reset);
+ const arc = arcs[i];
+ const properties = {
+ x: centerX + this.offsetX,
+ y: centerY + this.offsetY,
+ startAngle,
+ endAngle: startAngle + circumference,
+ circumference,
+ outerRadius,
+ innerRadius
+ };
+ if (includeOptions) {
+ properties.options = sharedOptions || this.resolveDataElementOptions(i, arc.active ? 'active' : mode);
+ }
+ startAngle += circumference;
+ this.updateElement(arc, i, properties, mode);
+ }
+ this.updateSharedOptions(sharedOptions, mode, firstOpts);
+ }
+ calculateTotal() {
+ const meta = this._cachedMeta;
+ const metaData = meta.data;
+ let total = 0;
+ let i;
+ for (i = 0; i < metaData.length; i++) {
+ const value = meta._parsed[i];
+ if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i) && !metaData[i].hidden) {
+ total += Math.abs(value);
+ }
+ }
+ return total;
+ }
+ calculateCircumference(value) {
+ const total = this._cachedMeta.total;
+ if (total > 0 && !isNaN(value)) {
+ return TAU * (Math.abs(value) / total);
+ }
+ return 0;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const chart = this.chart;
+ const labels = chart.data.labels || [];
+ const value = formatNumber(meta._parsed[index], chart.options.locale);
+ return {
+ label: labels[index] || '',
+ value,
+ };
+ }
+ getMaxBorderWidth(arcs) {
+ let max = 0;
+ const chart = this.chart;
+ let i, ilen, meta, controller, options;
+ if (!arcs) {
+ for (i = 0, ilen = chart.data.datasets.length; i < ilen; ++i) {
+ if (chart.isDatasetVisible(i)) {
+ meta = chart.getDatasetMeta(i);
+ arcs = meta.data;
+ controller = meta.controller;
+ break;
+ }
+ }
+ }
+ if (!arcs) {
+ return 0;
+ }
+ for (i = 0, ilen = arcs.length; i < ilen; ++i) {
+ options = controller.resolveDataElementOptions(i);
+ if (options.borderAlign !== 'inner') {
+ max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0);
+ }
+ }
+ return max;
+ }
+ getMaxOffset(arcs) {
+ let max = 0;
+ for (let i = 0, ilen = arcs.length; i < ilen; ++i) {
+ const options = this.resolveDataElementOptions(i);
+ max = Math.max(max, options.offset || 0, options.hoverOffset || 0);
+ }
+ return max;
+ }
+ _getRingWeightOffset(datasetIndex) {
+ let ringWeightOffset = 0;
+ for (let i = 0; i < datasetIndex; ++i) {
+ if (this.chart.isDatasetVisible(i)) {
+ ringWeightOffset += this._getRingWeight(i);
+ }
+ }
+ return ringWeightOffset;
+ }
+ _getRingWeight(datasetIndex) {
+ return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0);
+ }
+ _getVisibleDatasetWeightTotal() {
+ return this._getRingWeightOffset(this.chart.data.datasets.length) || 1;
+ }
+}
+DoughnutController.id = 'doughnut';
+DoughnutController.defaults = {
+ datasetElementType: false,
+ dataElementType: 'arc',
+ animation: {
+ animateRotate: true,
+ animateScale: false
+ },
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: ['circumference', 'endAngle', 'innerRadius', 'outerRadius', 'startAngle', 'x', 'y', 'offset', 'borderWidth', 'spacing']
+ },
+ },
+ cutout: '50%',
+ rotation: 0,
+ circumference: 360,
+ radius: '100%',
+ spacing: 0,
+ indexAxis: 'r',
+};
+DoughnutController.descriptors = {
+ _scriptable: (name) => name !== 'spacing',
+ _indexable: (name) => name !== 'spacing',
+};
+DoughnutController.overrides = {
+ aspectRatio: 1,
+ plugins: {
+ legend: {
+ labels: {
+ generateLabels(chart) {
+ const data = chart.data;
+ if (data.labels.length && data.datasets.length) {
+ const {labels: {pointStyle}} = chart.legend.options;
+ return data.labels.map((label, i) => {
+ const meta = chart.getDatasetMeta(0);
+ const style = meta.controller.getStyle(i);
+ return {
+ text: label,
+ fillStyle: style.backgroundColor,
+ strokeStyle: style.borderColor,
+ lineWidth: style.borderWidth,
+ pointStyle: pointStyle,
+ hidden: !chart.getDataVisibility(i),
+ index: i
+ };
+ });
+ }
+ return [];
+ }
+ },
+ onClick(e, legendItem, legend) {
+ legend.chart.toggleDataVisibility(legendItem.index);
+ legend.chart.update();
+ }
+ },
+ tooltip: {
+ callbacks: {
+ title() {
+ return '';
+ },
+ label(tooltipItem) {
+ let dataLabel = tooltipItem.label;
+ const value = ': ' + tooltipItem.formattedValue;
+ if (isArray(dataLabel)) {
+ dataLabel = dataLabel.slice();
+ dataLabel[0] += value;
+ } else {
+ dataLabel += value;
+ }
+ return dataLabel;
+ }
+ }
+ }
+ }
+};
+
+class LineController extends DatasetController {
+ initialize() {
+ this.enableOptionSharing = true;
+ super.initialize();
+ }
+ update(mode) {
+ const meta = this._cachedMeta;
+ const {dataset: line, data: points = [], _dataset} = meta;
+ const animationsDisabled = this.chart._animationsDisabled;
+ let {start, count} = getStartAndCountOfVisiblePoints(meta, points, animationsDisabled);
+ this._drawStart = start;
+ this._drawCount = count;
+ if (scaleRangesChanged(meta)) {
+ start = 0;
+ count = points.length;
+ }
+ line._chart = this.chart;
+ line._datasetIndex = this.index;
+ line._decimated = !!_dataset._decimated;
+ line.points = points;
+ const options = this.resolveDatasetElementOptions(mode);
+ if (!this.options.showLine) {
+ options.borderWidth = 0;
+ }
+ options.segment = this.options.segment;
+ this.updateElement(line, undefined, {
+ animated: !animationsDisabled,
+ options
+ }, mode);
+ this.updateElements(points, start, count, mode);
+ }
+ updateElements(points, start, count, mode) {
+ const reset = mode === 'reset';
+ const {iScale, vScale, _stacked, _dataset} = this._cachedMeta;
+ const firstOpts = this.resolveDataElementOptions(start, mode);
+ const sharedOptions = this.getSharedOptions(firstOpts);
+ const includeOptions = this.includeOptions(mode, sharedOptions);
+ const iAxis = iScale.axis;
+ const vAxis = vScale.axis;
+ const {spanGaps, segment} = this.options;
+ const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY;
+ const directUpdate = this.chart._animationsDisabled || reset || mode === 'none';
+ let prevParsed = start > 0 && this.getParsed(start - 1);
+ for (let i = start; i < start + count; ++i) {
+ const point = points[i];
+ const parsed = this.getParsed(i);
+ const properties = directUpdate ? point : {};
+ const nullData = isNullOrUndef(parsed[vAxis]);
+ const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i);
+ const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i);
+ properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData;
+ properties.stop = i > 0 && (parsed[iAxis] - prevParsed[iAxis]) > maxGapLength;
+ if (segment) {
+ properties.parsed = parsed;
+ properties.raw = _dataset.data[i];
+ }
+ if (includeOptions) {
+ properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode);
+ }
+ if (!directUpdate) {
+ this.updateElement(point, i, properties, mode);
+ }
+ prevParsed = parsed;
+ }
+ this.updateSharedOptions(sharedOptions, mode, firstOpts);
+ }
+ getMaxOverflow() {
+ const meta = this._cachedMeta;
+ const dataset = meta.dataset;
+ const border = dataset.options && dataset.options.borderWidth || 0;
+ const data = meta.data || [];
+ if (!data.length) {
+ return border;
+ }
+ const firstPoint = data[0].size(this.resolveDataElementOptions(0));
+ const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1));
+ return Math.max(border, firstPoint, lastPoint) / 2;
+ }
+ draw() {
+ const meta = this._cachedMeta;
+ meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis);
+ super.draw();
+ }
+}
+LineController.id = 'line';
+LineController.defaults = {
+ datasetElementType: 'line',
+ dataElementType: 'point',
+ showLine: true,
+ spanGaps: false,
+};
+LineController.overrides = {
+ scales: {
+ _index_: {
+ type: 'category',
+ },
+ _value_: {
+ type: 'linear',
+ },
+ }
+};
+function getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) {
+ const pointCount = points.length;
+ let start = 0;
+ let count = pointCount;
+ if (meta._sorted) {
+ const {iScale, _parsed} = meta;
+ const axis = iScale.axis;
+ const {min, max, minDefined, maxDefined} = iScale.getUserBounds();
+ if (minDefined) {
+ start = _limitValue(Math.min(
+ _lookupByKey(_parsed, iScale.axis, min).lo,
+ animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo),
+ 0, pointCount - 1);
+ }
+ if (maxDefined) {
+ count = _limitValue(Math.max(
+ _lookupByKey(_parsed, iScale.axis, max).hi + 1,
+ animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max)).hi + 1),
+ start, pointCount) - start;
+ } else {
+ count = pointCount - start;
+ }
+ }
+ return {start, count};
+}
+function scaleRangesChanged(meta) {
+ const {xScale, yScale, _scaleRanges} = meta;
+ const newRanges = {
+ xmin: xScale.min,
+ xmax: xScale.max,
+ ymin: yScale.min,
+ ymax: yScale.max
+ };
+ if (!_scaleRanges) {
+ meta._scaleRanges = newRanges;
+ return true;
+ }
+ const changed = _scaleRanges.xmin !== xScale.min
+ || _scaleRanges.xmax !== xScale.max
+ || _scaleRanges.ymin !== yScale.min
+ || _scaleRanges.ymax !== yScale.max;
+ Object.assign(_scaleRanges, newRanges);
+ return changed;
+}
+
+class PolarAreaController extends DatasetController {
+ constructor(chart, datasetIndex) {
+ super(chart, datasetIndex);
+ this.innerRadius = undefined;
+ this.outerRadius = undefined;
+ }
+ getLabelAndValue(index) {
+ const meta = this._cachedMeta;
+ const chart = this.chart;
+ const labels = chart.data.labels || [];
+ const value = formatNumber(meta._parsed[index].r, chart.options.locale);
+ return {
+ label: labels[index] || '',
+ value,
+ };
+ }
+ update(mode) {
+ const arcs = this._cachedMeta.data;
+ this._updateRadius();
+ this.updateElements(arcs, 0, arcs.length, mode);
+ }
+ _updateRadius() {
+ const chart = this.chart;
+ const chartArea = chart.chartArea;
+ const opts = chart.options;
+ const minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);
+ const outerRadius = Math.max(minSize / 2, 0);
+ const innerRadius = Math.max(opts.cutoutPercentage ? (outerRadius / 100) * (opts.cutoutPercentage) : 1, 0);
+ const radiusLength = (outerRadius - innerRadius) / chart.getVisibleDatasetCount();
+ this.outerRadius = outerRadius - (radiusLength * this.index);
+ this.innerRadius = this.outerRadius - radiusLength;
+ }
+ updateElements(arcs, start, count, mode) {
+ const reset = mode === 'reset';
+ const chart = this.chart;
+ const dataset = this.getDataset();
+ const opts = chart.options;
+ const animationOpts = opts.animation;
+ const scale = this._cachedMeta.rScale;
+ const centerX = scale.xCenter;
+ const centerY = scale.yCenter;
+ const datasetStartAngle = scale.getIndexAngle(0) - 0.5 * PI;
+ let angle = datasetStartAngle;
+ let i;
+ const defaultAngle = 360 / this.countVisibleElements();
+ for (i = 0; i < start; ++i) {
+ angle += this._computeAngle(i, mode, defaultAngle);
+ }
+ for (i = start; i < start + count; i++) {
+ const arc = arcs[i];
+ let startAngle = angle;
+ let endAngle = angle + this._computeAngle(i, mode, defaultAngle);
+ let outerRadius = chart.getDataVisibility(i) ? scale.getDistanceFromCenterForValue(dataset.data[i]) : 0;
+ angle = endAngle;
+ if (reset) {
+ if (animationOpts.animateScale) {
+ outerRadius = 0;
+ }
+ if (animationOpts.animateRotate) {
+ startAngle = endAngle = datasetStartAngle;
+ }
+ }
+ const properties = {
+ x: centerX,
+ y: centerY,
+ innerRadius: 0,
+ outerRadius,
+ startAngle,
+ endAngle,
+ options: this.resolveDataElementOptions(i, arc.active ? 'active' : mode)
+ };
+ this.updateElement(arc, i, properties, mode);
+ }
+ }
+ countVisibleElements() {
+ const dataset = this.getDataset();
+ const meta = this._cachedMeta;
+ let count = 0;
+ meta.data.forEach((element, index) => {
+ if (!isNaN(dataset.data[index]) && this.chart.getDataVisibility(index)) {
+ count++;
+ }
+ });
+ return count;
+ }
+ _computeAngle(index, mode, defaultAngle) {
+ return this.chart.getDataVisibility(index)
+ ? toRadians(this.resolveDataElementOptions(index, mode).angle || defaultAngle)
+ : 0;
+ }
+}
+PolarAreaController.id = 'polarArea';
+PolarAreaController.defaults = {
+ dataElementType: 'arc',
+ animation: {
+ animateRotate: true,
+ animateScale: true
+ },
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: ['x', 'y', 'startAngle', 'endAngle', 'innerRadius', 'outerRadius']
+ },
+ },
+ indexAxis: 'r',
+ startAngle: 0,
+};
+PolarAreaController.overrides = {
+ aspectRatio: 1,
+ plugins: {
+ legend: {
+ labels: {
+ generateLabels(chart) {
+ const data = chart.data;
+ if (data.labels.length && data.datasets.length) {
+ const {labels: {pointStyle}} = chart.legend.options;
+ return data.labels.map((label, i) => {
+ const meta = chart.getDatasetMeta(0);
+ const style = meta.controller.getStyle(i);
+ return {
+ text: label,
+ fillStyle: style.backgroundColor,
+ strokeStyle: style.borderColor,
+ lineWidth: style.borderWidth,
+ pointStyle: pointStyle,
+ hidden: !chart.getDataVisibility(i),
+ index: i
+ };
+ });
+ }
+ return [];
+ }
+ },
+ onClick(e, legendItem, legend) {
+ legend.chart.toggleDataVisibility(legendItem.index);
+ legend.chart.update();
+ }
+ },
+ tooltip: {
+ callbacks: {
+ title() {
+ return '';
+ },
+ label(context) {
+ return context.chart.data.labels[context.dataIndex] + ': ' + context.formattedValue;
+ }
+ }
+ }
+ },
+ scales: {
+ r: {
+ type: 'radialLinear',
+ angleLines: {
+ display: false
+ },
+ beginAtZero: true,
+ grid: {
+ circular: true
+ },
+ pointLabels: {
+ display: false
+ },
+ startAngle: 0
+ }
+ }
+};
+
+class PieController extends DoughnutController {
+}
+PieController.id = 'pie';
+PieController.defaults = {
+ cutout: 0,
+ rotation: 0,
+ circumference: 360,
+ radius: '100%'
+};
+
+class RadarController extends DatasetController {
+ getLabelAndValue(index) {
+ const vScale = this._cachedMeta.vScale;
+ const parsed = this.getParsed(index);
+ return {
+ label: vScale.getLabels()[index],
+ value: '' + vScale.getLabelForValue(parsed[vScale.axis])
+ };
+ }
+ update(mode) {
+ const meta = this._cachedMeta;
+ const line = meta.dataset;
+ const points = meta.data || [];
+ const labels = meta.iScale.getLabels();
+ line.points = points;
+ if (mode !== 'resize') {
+ const options = this.resolveDatasetElementOptions(mode);
+ if (!this.options.showLine) {
+ options.borderWidth = 0;
+ }
+ const properties = {
+ _loop: true,
+ _fullLoop: labels.length === points.length,
+ options
+ };
+ this.updateElement(line, undefined, properties, mode);
+ }
+ this.updateElements(points, 0, points.length, mode);
+ }
+ updateElements(points, start, count, mode) {
+ const dataset = this.getDataset();
+ const scale = this._cachedMeta.rScale;
+ const reset = mode === 'reset';
+ for (let i = start; i < start + count; i++) {
+ const point = points[i];
+ const options = this.resolveDataElementOptions(i, point.active ? 'active' : mode);
+ const pointPosition = scale.getPointPositionForValue(i, dataset.data[i]);
+ const x = reset ? scale.xCenter : pointPosition.x;
+ const y = reset ? scale.yCenter : pointPosition.y;
+ const properties = {
+ x,
+ y,
+ angle: pointPosition.angle,
+ skip: isNaN(x) || isNaN(y),
+ options
+ };
+ this.updateElement(point, i, properties, mode);
+ }
+ }
+}
+RadarController.id = 'radar';
+RadarController.defaults = {
+ datasetElementType: 'line',
+ dataElementType: 'point',
+ indexAxis: 'r',
+ showLine: true,
+ elements: {
+ line: {
+ fill: 'start'
+ }
+ },
+};
+RadarController.overrides = {
+ aspectRatio: 1,
+ scales: {
+ r: {
+ type: 'radialLinear',
+ }
+ }
+};
+
+class ScatterController extends LineController {
+}
+ScatterController.id = 'scatter';
+ScatterController.defaults = {
+ showLine: false,
+ fill: false
+};
+ScatterController.overrides = {
+ interaction: {
+ mode: 'point'
+ },
+ plugins: {
+ tooltip: {
+ callbacks: {
+ title() {
+ return '';
+ },
+ label(item) {
+ return '(' + item.label + ', ' + item.formattedValue + ')';
+ }
+ }
+ }
+ },
+ scales: {
+ x: {
+ type: 'linear'
+ },
+ y: {
+ type: 'linear'
+ }
+ }
+};
+
+var controllers = /*#__PURE__*/Object.freeze({
+__proto__: null,
+BarController: BarController,
+BubbleController: BubbleController,
+DoughnutController: DoughnutController,
+LineController: LineController,
+PolarAreaController: PolarAreaController,
+PieController: PieController,
+RadarController: RadarController,
+ScatterController: ScatterController
+});
+
+function clipArc(ctx, element, endAngle) {
+ const {startAngle, pixelMargin, x, y, outerRadius, innerRadius} = element;
+ let angleMargin = pixelMargin / outerRadius;
+ ctx.beginPath();
+ ctx.arc(x, y, outerRadius, startAngle - angleMargin, endAngle + angleMargin);
+ if (innerRadius > pixelMargin) {
+ angleMargin = pixelMargin / innerRadius;
+ ctx.arc(x, y, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true);
+ } else {
+ ctx.arc(x, y, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI);
+ }
+ ctx.closePath();
+ ctx.clip();
+}
+function toRadiusCorners(value) {
+ return _readValueToProps(value, ['outerStart', 'outerEnd', 'innerStart', 'innerEnd']);
+}
+function parseBorderRadius$1(arc, innerRadius, outerRadius, angleDelta) {
+ const o = toRadiusCorners(arc.options.borderRadius);
+ const halfThickness = (outerRadius - innerRadius) / 2;
+ const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2);
+ const computeOuterLimit = (val) => {
+ const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2;
+ return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit));
+ };
+ return {
+ outerStart: computeOuterLimit(o.outerStart),
+ outerEnd: computeOuterLimit(o.outerEnd),
+ innerStart: _limitValue(o.innerStart, 0, innerLimit),
+ innerEnd: _limitValue(o.innerEnd, 0, innerLimit),
+ };
+}
+function rThetaToXY(r, theta, x, y) {
+ return {
+ x: x + r * Math.cos(theta),
+ y: y + r * Math.sin(theta),
+ };
+}
+function pathArc(ctx, element, offset, spacing, end) {
+ const {x, y, startAngle: start, pixelMargin, innerRadius: innerR} = element;
+ const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0);
+ const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0;
+ let spacingOffset = 0;
+ const alpha = end - start;
+ if (spacing) {
+ const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0;
+ const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0;
+ const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2;
+ const adjustedAngle = avNogSpacingRadius !== 0 ? (alpha * avNogSpacingRadius) / (avNogSpacingRadius + spacing) : alpha;
+ spacingOffset = (alpha - adjustedAngle) / 2;
+ }
+ const beta = Math.max(0.001, alpha * outerRadius - offset / PI) / outerRadius;
+ const angleOffset = (alpha - beta) / 2;
+ const startAngle = start + angleOffset + spacingOffset;
+ const endAngle = end - angleOffset - spacingOffset;
+ const {outerStart, outerEnd, innerStart, innerEnd} = parseBorderRadius$1(element, innerRadius, outerRadius, endAngle - startAngle);
+ const outerStartAdjustedRadius = outerRadius - outerStart;
+ const outerEndAdjustedRadius = outerRadius - outerEnd;
+ const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius;
+ const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius;
+ const innerStartAdjustedRadius = innerRadius + innerStart;
+ const innerEndAdjustedRadius = innerRadius + innerEnd;
+ const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius;
+ const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius;
+ ctx.beginPath();
+ ctx.arc(x, y, outerRadius, outerStartAdjustedAngle, outerEndAdjustedAngle);
+ if (outerEnd > 0) {
+ const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x, y);
+ ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI);
+ }
+ const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x, y);
+ ctx.lineTo(p4.x, p4.y);
+ if (innerEnd > 0) {
+ const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x, y);
+ ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI);
+ }
+ ctx.arc(x, y, innerRadius, endAngle - (innerEnd / innerRadius), startAngle + (innerStart / innerRadius), true);
+ if (innerStart > 0) {
+ const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x, y);
+ ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI);
+ }
+ const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x, y);
+ ctx.lineTo(p8.x, p8.y);
+ if (outerStart > 0) {
+ const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x, y);
+ ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle);
+ }
+ ctx.closePath();
+}
+function drawArc(ctx, element, offset, spacing) {
+ const {fullCircles, startAngle, circumference} = element;
+ let endAngle = element.endAngle;
+ if (fullCircles) {
+ pathArc(ctx, element, offset, spacing, startAngle + TAU);
+ for (let i = 0; i < fullCircles; ++i) {
+ ctx.fill();
+ }
+ if (!isNaN(circumference)) {
+ endAngle = startAngle + circumference % TAU;
+ if (circumference % TAU === 0) {
+ endAngle += TAU;
+ }
+ }
+ }
+ pathArc(ctx, element, offset, spacing, endAngle);
+ ctx.fill();
+ return endAngle;
+}
+function drawFullCircleBorders(ctx, element, inner) {
+ const {x, y, startAngle, pixelMargin, fullCircles} = element;
+ const outerRadius = Math.max(element.outerRadius - pixelMargin, 0);
+ const innerRadius = element.innerRadius + pixelMargin;
+ let i;
+ if (inner) {
+ clipArc(ctx, element, startAngle + TAU);
+ }
+ ctx.beginPath();
+ ctx.arc(x, y, innerRadius, startAngle + TAU, startAngle, true);
+ for (i = 0; i < fullCircles; ++i) {
+ ctx.stroke();
+ }
+ ctx.beginPath();
+ ctx.arc(x, y, outerRadius, startAngle, startAngle + TAU);
+ for (i = 0; i < fullCircles; ++i) {
+ ctx.stroke();
+ }
+}
+function drawBorder(ctx, element, offset, spacing, endAngle) {
+ const {options} = element;
+ const {borderWidth, borderJoinStyle} = options;
+ const inner = options.borderAlign === 'inner';
+ if (!borderWidth) {
+ return;
+ }
+ if (inner) {
+ ctx.lineWidth = borderWidth * 2;
+ ctx.lineJoin = borderJoinStyle || 'round';
+ } else {
+ ctx.lineWidth = borderWidth;
+ ctx.lineJoin = borderJoinStyle || 'bevel';
+ }
+ if (element.fullCircles) {
+ drawFullCircleBorders(ctx, element, inner);
+ }
+ if (inner) {
+ clipArc(ctx, element, endAngle);
+ }
+ pathArc(ctx, element, offset, spacing, endAngle);
+ ctx.stroke();
+}
+class ArcElement extends Element {
+ constructor(cfg) {
+ super();
+ this.options = undefined;
+ this.circumference = undefined;
+ this.startAngle = undefined;
+ this.endAngle = undefined;
+ this.innerRadius = undefined;
+ this.outerRadius = undefined;
+ this.pixelMargin = 0;
+ this.fullCircles = 0;
+ if (cfg) {
+ Object.assign(this, cfg);
+ }
+ }
+ inRange(chartX, chartY, useFinalPosition) {
+ const point = this.getProps(['x', 'y'], useFinalPosition);
+ const {angle, distance} = getAngleFromPoint(point, {x: chartX, y: chartY});
+ const {startAngle, endAngle, innerRadius, outerRadius, circumference} = this.getProps([
+ 'startAngle',
+ 'endAngle',
+ 'innerRadius',
+ 'outerRadius',
+ 'circumference'
+ ], useFinalPosition);
+ const rAdjust = this.options.spacing / 2;
+ const _circumference = valueOrDefault(circumference, endAngle - startAngle);
+ const betweenAngles = _circumference >= TAU || _angleBetween(angle, startAngle, endAngle);
+ const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust);
+ return (betweenAngles && withinRadius);
+ }
+ getCenterPoint(useFinalPosition) {
+ const {x, y, startAngle, endAngle, innerRadius, outerRadius} = this.getProps([
+ 'x',
+ 'y',
+ 'startAngle',
+ 'endAngle',
+ 'innerRadius',
+ 'outerRadius',
+ 'circumference',
+ ], useFinalPosition);
+ const {offset, spacing} = this.options;
+ const halfAngle = (startAngle + endAngle) / 2;
+ const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2;
+ return {
+ x: x + Math.cos(halfAngle) * halfRadius,
+ y: y + Math.sin(halfAngle) * halfRadius
+ };
+ }
+ tooltipPosition(useFinalPosition) {
+ return this.getCenterPoint(useFinalPosition);
+ }
+ draw(ctx) {
+ const {options, circumference} = this;
+ const offset = (options.offset || 0) / 2;
+ const spacing = (options.spacing || 0) / 2;
+ this.pixelMargin = (options.borderAlign === 'inner') ? 0.33 : 0;
+ this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0;
+ if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) {
+ return;
+ }
+ ctx.save();
+ let radiusOffset = 0;
+ if (offset) {
+ radiusOffset = offset / 2;
+ const halfAngle = (this.startAngle + this.endAngle) / 2;
+ ctx.translate(Math.cos(halfAngle) * radiusOffset, Math.sin(halfAngle) * radiusOffset);
+ if (this.circumference >= PI) {
+ radiusOffset = offset;
+ }
+ }
+ ctx.fillStyle = options.backgroundColor;
+ ctx.strokeStyle = options.borderColor;
+ const endAngle = drawArc(ctx, this, radiusOffset, spacing);
+ drawBorder(ctx, this, radiusOffset, spacing, endAngle);
+ ctx.restore();
+ }
+}
+ArcElement.id = 'arc';
+ArcElement.defaults = {
+ borderAlign: 'center',
+ borderColor: '#fff',
+ borderJoinStyle: undefined,
+ borderRadius: 0,
+ borderWidth: 2,
+ offset: 0,
+ spacing: 0,
+ angle: undefined,
+};
+ArcElement.defaultRoutes = {
+ backgroundColor: 'backgroundColor'
+};
+
+function setStyle(ctx, options, style = options) {
+ ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle);
+ ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash));
+ ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset);
+ ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle);
+ ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth);
+ ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor);
+}
+function lineTo(ctx, previous, target) {
+ ctx.lineTo(target.x, target.y);
+}
+function getLineMethod(options) {
+ if (options.stepped) {
+ return _steppedLineTo;
+ }
+ if (options.tension || options.cubicInterpolationMode === 'monotone') {
+ return _bezierCurveTo;
+ }
+ return lineTo;
+}
+function pathVars(points, segment, params = {}) {
+ const count = points.length;
+ const {start: paramsStart = 0, end: paramsEnd = count - 1} = params;
+ const {start: segmentStart, end: segmentEnd} = segment;
+ const start = Math.max(paramsStart, segmentStart);
+ const end = Math.min(paramsEnd, segmentEnd);
+ const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd;
+ return {
+ count,
+ start,
+ loop: segment.loop,
+ ilen: end < start && !outside ? count + end - start : end - start
+ };
+}
+function pathSegment(ctx, line, segment, params) {
+ const {points, options} = line;
+ const {count, start, loop, ilen} = pathVars(points, segment, params);
+ const lineMethod = getLineMethod(options);
+ let {move = true, reverse} = params || {};
+ let i, point, prev;
+ for (i = 0; i <= ilen; ++i) {
+ point = points[(start + (reverse ? ilen - i : i)) % count];
+ if (point.skip) {
+ continue;
+ } else if (move) {
+ ctx.moveTo(point.x, point.y);
+ move = false;
+ } else {
+ lineMethod(ctx, prev, point, reverse, options.stepped);
+ }
+ prev = point;
+ }
+ if (loop) {
+ point = points[(start + (reverse ? ilen : 0)) % count];
+ lineMethod(ctx, prev, point, reverse, options.stepped);
+ }
+ return !!loop;
+}
+function fastPathSegment(ctx, line, segment, params) {
+ const points = line.points;
+ const {count, start, ilen} = pathVars(points, segment, params);
+ const {move = true, reverse} = params || {};
+ let avgX = 0;
+ let countX = 0;
+ let i, point, prevX, minY, maxY, lastY;
+ const pointIndex = (index) => (start + (reverse ? ilen - index : index)) % count;
+ const drawX = () => {
+ if (minY !== maxY) {
+ ctx.lineTo(avgX, maxY);
+ ctx.lineTo(avgX, minY);
+ ctx.lineTo(avgX, lastY);
+ }
+ };
+ if (move) {
+ point = points[pointIndex(0)];
+ ctx.moveTo(point.x, point.y);
+ }
+ for (i = 0; i <= ilen; ++i) {
+ point = points[pointIndex(i)];
+ if (point.skip) {
+ continue;
+ }
+ const x = point.x;
+ const y = point.y;
+ const truncX = x | 0;
+ if (truncX === prevX) {
+ if (y < minY) {
+ minY = y;
+ } else if (y > maxY) {
+ maxY = y;
+ }
+ avgX = (countX * avgX + x) / ++countX;
+ } else {
+ drawX();
+ ctx.lineTo(x, y);
+ prevX = truncX;
+ countX = 0;
+ minY = maxY = y;
+ }
+ lastY = y;
+ }
+ drawX();
+}
+function _getSegmentMethod(line) {
+ const opts = line.options;
+ const borderDash = opts.borderDash && opts.borderDash.length;
+ const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== 'monotone' && !opts.stepped && !borderDash;
+ return useFastPath ? fastPathSegment : pathSegment;
+}
+function _getInterpolationMethod(options) {
+ if (options.stepped) {
+ return _steppedInterpolation;
+ }
+ if (options.tension || options.cubicInterpolationMode === 'monotone') {
+ return _bezierInterpolation;
+ }
+ return _pointInLine;
+}
+function strokePathWithCache(ctx, line, start, count) {
+ let path = line._path;
+ if (!path) {
+ path = line._path = new Path2D();
+ if (line.path(path, start, count)) {
+ path.closePath();
+ }
+ }
+ setStyle(ctx, line.options);
+ ctx.stroke(path);
+}
+function strokePathDirect(ctx, line, start, count) {
+ const {segments, options} = line;
+ const segmentMethod = _getSegmentMethod(line);
+ for (const segment of segments) {
+ setStyle(ctx, options, segment.style);
+ ctx.beginPath();
+ if (segmentMethod(ctx, line, segment, {start, end: start + count - 1})) {
+ ctx.closePath();
+ }
+ ctx.stroke();
+ }
+}
+const usePath2D = typeof Path2D === 'function';
+function draw(ctx, line, start, count) {
+ if (usePath2D && !line.options.segment) {
+ strokePathWithCache(ctx, line, start, count);
+ } else {
+ strokePathDirect(ctx, line, start, count);
+ }
+}
+class LineElement extends Element {
+ constructor(cfg) {
+ super();
+ this.animated = true;
+ this.options = undefined;
+ this._chart = undefined;
+ this._loop = undefined;
+ this._fullLoop = undefined;
+ this._path = undefined;
+ this._points = undefined;
+ this._segments = undefined;
+ this._decimated = false;
+ this._pointsUpdated = false;
+ this._datasetIndex = undefined;
+ if (cfg) {
+ Object.assign(this, cfg);
+ }
+ }
+ updateControlPoints(chartArea, indexAxis) {
+ const options = this.options;
+ if ((options.tension || options.cubicInterpolationMode === 'monotone') && !options.stepped && !this._pointsUpdated) {
+ const loop = options.spanGaps ? this._loop : this._fullLoop;
+ _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis);
+ this._pointsUpdated = true;
+ }
+ }
+ set points(points) {
+ this._points = points;
+ delete this._segments;
+ delete this._path;
+ this._pointsUpdated = false;
+ }
+ get points() {
+ return this._points;
+ }
+ get segments() {
+ return this._segments || (this._segments = _computeSegments(this, this.options.segment));
+ }
+ first() {
+ const segments = this.segments;
+ const points = this.points;
+ return segments.length && points[segments[0].start];
+ }
+ last() {
+ const segments = this.segments;
+ const points = this.points;
+ const count = segments.length;
+ return count && points[segments[count - 1].end];
+ }
+ interpolate(point, property) {
+ const options = this.options;
+ const value = point[property];
+ const points = this.points;
+ const segments = _boundSegments(this, {property, start: value, end: value});
+ if (!segments.length) {
+ return;
+ }
+ const result = [];
+ const _interpolate = _getInterpolationMethod(options);
+ let i, ilen;
+ for (i = 0, ilen = segments.length; i < ilen; ++i) {
+ const {start, end} = segments[i];
+ const p1 = points[start];
+ const p2 = points[end];
+ if (p1 === p2) {
+ result.push(p1);
+ continue;
+ }
+ const t = Math.abs((value - p1[property]) / (p2[property] - p1[property]));
+ const interpolated = _interpolate(p1, p2, t, options.stepped);
+ interpolated[property] = point[property];
+ result.push(interpolated);
+ }
+ return result.length === 1 ? result[0] : result;
+ }
+ pathSegment(ctx, segment, params) {
+ const segmentMethod = _getSegmentMethod(this);
+ return segmentMethod(ctx, this, segment, params);
+ }
+ path(ctx, start, count) {
+ const segments = this.segments;
+ const segmentMethod = _getSegmentMethod(this);
+ let loop = this._loop;
+ start = start || 0;
+ count = count || (this.points.length - start);
+ for (const segment of segments) {
+ loop &= segmentMethod(ctx, this, segment, {start, end: start + count - 1});
+ }
+ return !!loop;
+ }
+ draw(ctx, chartArea, start, count) {
+ const options = this.options || {};
+ const points = this.points || [];
+ if (points.length && options.borderWidth) {
+ ctx.save();
+ draw(ctx, this, start, count);
+ ctx.restore();
+ }
+ if (this.animated) {
+ this._pointsUpdated = false;
+ this._path = undefined;
+ }
+ }
+}
+LineElement.id = 'line';
+LineElement.defaults = {
+ borderCapStyle: 'butt',
+ borderDash: [],
+ borderDashOffset: 0,
+ borderJoinStyle: 'miter',
+ borderWidth: 3,
+ capBezierPoints: true,
+ cubicInterpolationMode: 'default',
+ fill: false,
+ spanGaps: false,
+ stepped: false,
+ tension: 0,
+};
+LineElement.defaultRoutes = {
+ backgroundColor: 'backgroundColor',
+ borderColor: 'borderColor'
+};
+LineElement.descriptors = {
+ _scriptable: true,
+ _indexable: (name) => name !== 'borderDash' && name !== 'fill',
+};
+
+function inRange$1(el, pos, axis, useFinalPosition) {
+ const options = el.options;
+ const {[axis]: value} = el.getProps([axis], useFinalPosition);
+ return (Math.abs(pos - value) < options.radius + options.hitRadius);
+}
+class PointElement extends Element {
+ constructor(cfg) {
+ super();
+ this.options = undefined;
+ this.parsed = undefined;
+ this.skip = undefined;
+ this.stop = undefined;
+ if (cfg) {
+ Object.assign(this, cfg);
+ }
+ }
+ inRange(mouseX, mouseY, useFinalPosition) {
+ const options = this.options;
+ const {x, y} = this.getProps(['x', 'y'], useFinalPosition);
+ return ((Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2)) < Math.pow(options.hitRadius + options.radius, 2));
+ }
+ inXRange(mouseX, useFinalPosition) {
+ return inRange$1(this, mouseX, 'x', useFinalPosition);
+ }
+ inYRange(mouseY, useFinalPosition) {
+ return inRange$1(this, mouseY, 'y', useFinalPosition);
+ }
+ getCenterPoint(useFinalPosition) {
+ const {x, y} = this.getProps(['x', 'y'], useFinalPosition);
+ return {x, y};
+ }
+ size(options) {
+ options = options || this.options || {};
+ let radius = options.radius || 0;
+ radius = Math.max(radius, radius && options.hoverRadius || 0);
+ const borderWidth = radius && options.borderWidth || 0;
+ return (radius + borderWidth) * 2;
+ }
+ draw(ctx, area) {
+ const options = this.options;
+ if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) {
+ return;
+ }
+ ctx.strokeStyle = options.borderColor;
+ ctx.lineWidth = options.borderWidth;
+ ctx.fillStyle = options.backgroundColor;
+ drawPoint(ctx, options, this.x, this.y);
+ }
+ getRange() {
+ const options = this.options || {};
+ return options.radius + options.hitRadius;
+ }
+}
+PointElement.id = 'point';
+PointElement.defaults = {
+ borderWidth: 1,
+ hitRadius: 1,
+ hoverBorderWidth: 1,
+ hoverRadius: 4,
+ pointStyle: 'circle',
+ radius: 3,
+ rotation: 0
+};
+PointElement.defaultRoutes = {
+ backgroundColor: 'backgroundColor',
+ borderColor: 'borderColor'
+};
+
+function getBarBounds(bar, useFinalPosition) {
+ const {x, y, base, width, height} = bar.getProps(['x', 'y', 'base', 'width', 'height'], useFinalPosition);
+ let left, right, top, bottom, half;
+ if (bar.horizontal) {
+ half = height / 2;
+ left = Math.min(x, base);
+ right = Math.max(x, base);
+ top = y - half;
+ bottom = y + half;
+ } else {
+ half = width / 2;
+ left = x - half;
+ right = x + half;
+ top = Math.min(y, base);
+ bottom = Math.max(y, base);
+ }
+ return {left, top, right, bottom};
+}
+function skipOrLimit(skip, value, min, max) {
+ return skip ? 0 : _limitValue(value, min, max);
+}
+function parseBorderWidth(bar, maxW, maxH) {
+ const value = bar.options.borderWidth;
+ const skip = bar.borderSkipped;
+ const o = toTRBL(value);
+ return {
+ t: skipOrLimit(skip.top, o.top, 0, maxH),
+ r: skipOrLimit(skip.right, o.right, 0, maxW),
+ b: skipOrLimit(skip.bottom, o.bottom, 0, maxH),
+ l: skipOrLimit(skip.left, o.left, 0, maxW)
+ };
+}
+function parseBorderRadius(bar, maxW, maxH) {
+ const {enableBorderRadius} = bar.getProps(['enableBorderRadius']);
+ const value = bar.options.borderRadius;
+ const o = toTRBLCorners(value);
+ const maxR = Math.min(maxW, maxH);
+ const skip = bar.borderSkipped;
+ const enableBorder = enableBorderRadius || isObject(value);
+ return {
+ topLeft: skipOrLimit(!enableBorder || skip.top || skip.left, o.topLeft, 0, maxR),
+ topRight: skipOrLimit(!enableBorder || skip.top || skip.right, o.topRight, 0, maxR),
+ bottomLeft: skipOrLimit(!enableBorder || skip.bottom || skip.left, o.bottomLeft, 0, maxR),
+ bottomRight: skipOrLimit(!enableBorder || skip.bottom || skip.right, o.bottomRight, 0, maxR)
+ };
+}
+function boundingRects(bar) {
+ const bounds = getBarBounds(bar);
+ const width = bounds.right - bounds.left;
+ const height = bounds.bottom - bounds.top;
+ const border = parseBorderWidth(bar, width / 2, height / 2);
+ const radius = parseBorderRadius(bar, width / 2, height / 2);
+ return {
+ outer: {
+ x: bounds.left,
+ y: bounds.top,
+ w: width,
+ h: height,
+ radius
+ },
+ inner: {
+ x: bounds.left + border.l,
+ y: bounds.top + border.t,
+ w: width - border.l - border.r,
+ h: height - border.t - border.b,
+ radius: {
+ topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)),
+ topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)),
+ bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)),
+ bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r)),
+ }
+ }
+ };
+}
+function inRange(bar, x, y, useFinalPosition) {
+ const skipX = x === null;
+ const skipY = y === null;
+ const skipBoth = skipX && skipY;
+ const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);
+ return bounds
+ && (skipX || _isBetween(x, bounds.left, bounds.right))
+ && (skipY || _isBetween(y, bounds.top, bounds.bottom));
+}
+function hasRadius(radius) {
+ return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;
+}
+function addNormalRectPath(ctx, rect) {
+ ctx.rect(rect.x, rect.y, rect.w, rect.h);
+}
+function inflateRect(rect, amount, refRect = {}) {
+ const x = rect.x !== refRect.x ? -amount : 0;
+ const y = rect.y !== refRect.y ? -amount : 0;
+ const w = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x;
+ const h = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y;
+ return {
+ x: rect.x + x,
+ y: rect.y + y,
+ w: rect.w + w,
+ h: rect.h + h,
+ radius: rect.radius
+ };
+}
+class BarElement extends Element {
+ constructor(cfg) {
+ super();
+ this.options = undefined;
+ this.horizontal = undefined;
+ this.base = undefined;
+ this.width = undefined;
+ this.height = undefined;
+ this.inflateAmount = undefined;
+ if (cfg) {
+ Object.assign(this, cfg);
+ }
+ }
+ draw(ctx) {
+ const {inflateAmount, options: {borderColor, backgroundColor}} = this;
+ const {inner, outer} = boundingRects(this);
+ const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath;
+ ctx.save();
+ if (outer.w !== inner.w || outer.h !== inner.h) {
+ ctx.beginPath();
+ addRectPath(ctx, inflateRect(outer, inflateAmount, inner));
+ ctx.clip();
+ addRectPath(ctx, inflateRect(inner, -inflateAmount, outer));
+ ctx.fillStyle = borderColor;
+ ctx.fill('evenodd');
+ }
+ ctx.beginPath();
+ addRectPath(ctx, inflateRect(inner, inflateAmount));
+ ctx.fillStyle = backgroundColor;
+ ctx.fill();
+ ctx.restore();
+ }
+ inRange(mouseX, mouseY, useFinalPosition) {
+ return inRange(this, mouseX, mouseY, useFinalPosition);
+ }
+ inXRange(mouseX, useFinalPosition) {
+ return inRange(this, mouseX, null, useFinalPosition);
+ }
+ inYRange(mouseY, useFinalPosition) {
+ return inRange(this, null, mouseY, useFinalPosition);
+ }
+ getCenterPoint(useFinalPosition) {
+ const {x, y, base, horizontal} = this.getProps(['x', 'y', 'base', 'horizontal'], useFinalPosition);
+ return {
+ x: horizontal ? (x + base) / 2 : x,
+ y: horizontal ? y : (y + base) / 2
+ };
+ }
+ getRange(axis) {
+ return axis === 'x' ? this.width / 2 : this.height / 2;
+ }
+}
+BarElement.id = 'bar';
+BarElement.defaults = {
+ borderSkipped: 'start',
+ borderWidth: 0,
+ borderRadius: 0,
+ inflateAmount: 'auto',
+ pointStyle: undefined
+};
+BarElement.defaultRoutes = {
+ backgroundColor: 'backgroundColor',
+ borderColor: 'borderColor'
+};
+
+var elements = /*#__PURE__*/Object.freeze({
+__proto__: null,
+ArcElement: ArcElement,
+LineElement: LineElement,
+PointElement: PointElement,
+BarElement: BarElement
+});
+
+function lttbDecimation(data, start, count, availableWidth, options) {
+ const samples = options.samples || availableWidth;
+ if (samples >= count) {
+ return data.slice(start, start + count);
+ }
+ const decimated = [];
+ const bucketWidth = (count - 2) / (samples - 2);
+ let sampledIndex = 0;
+ const endIndex = start + count - 1;
+ let a = start;
+ let i, maxAreaPoint, maxArea, area, nextA;
+ decimated[sampledIndex++] = data[a];
+ for (i = 0; i < samples - 2; i++) {
+ let avgX = 0;
+ let avgY = 0;
+ let j;
+ const avgRangeStart = Math.floor((i + 1) * bucketWidth) + 1 + start;
+ const avgRangeEnd = Math.min(Math.floor((i + 2) * bucketWidth) + 1, count) + start;
+ const avgRangeLength = avgRangeEnd - avgRangeStart;
+ for (j = avgRangeStart; j < avgRangeEnd; j++) {
+ avgX += data[j].x;
+ avgY += data[j].y;
+ }
+ avgX /= avgRangeLength;
+ avgY /= avgRangeLength;
+ const rangeOffs = Math.floor(i * bucketWidth) + 1 + start;
+ const rangeTo = Math.min(Math.floor((i + 1) * bucketWidth) + 1, count) + start;
+ const {x: pointAx, y: pointAy} = data[a];
+ maxArea = area = -1;
+ for (j = rangeOffs; j < rangeTo; j++) {
+ area = 0.5 * Math.abs(
+ (pointAx - avgX) * (data[j].y - pointAy) -
+ (pointAx - data[j].x) * (avgY - pointAy)
+ );
+ if (area > maxArea) {
+ maxArea = area;
+ maxAreaPoint = data[j];
+ nextA = j;
+ }
+ }
+ decimated[sampledIndex++] = maxAreaPoint;
+ a = nextA;
+ }
+ decimated[sampledIndex++] = data[endIndex];
+ return decimated;
+}
+function minMaxDecimation(data, start, count, availableWidth) {
+ let avgX = 0;
+ let countX = 0;
+ let i, point, x, y, prevX, minIndex, maxIndex, startIndex, minY, maxY;
+ const decimated = [];
+ const endIndex = start + count - 1;
+ const xMin = data[start].x;
+ const xMax = data[endIndex].x;
+ const dx = xMax - xMin;
+ for (i = start; i < start + count; ++i) {
+ point = data[i];
+ x = (point.x - xMin) / dx * availableWidth;
+ y = point.y;
+ const truncX = x | 0;
+ if (truncX === prevX) {
+ if (y < minY) {
+ minY = y;
+ minIndex = i;
+ } else if (y > maxY) {
+ maxY = y;
+ maxIndex = i;
+ }
+ avgX = (countX * avgX + point.x) / ++countX;
+ } else {
+ const lastIndex = i - 1;
+ if (!isNullOrUndef(minIndex) && !isNullOrUndef(maxIndex)) {
+ const intermediateIndex1 = Math.min(minIndex, maxIndex);
+ const intermediateIndex2 = Math.max(minIndex, maxIndex);
+ if (intermediateIndex1 !== startIndex && intermediateIndex1 !== lastIndex) {
+ decimated.push({
+ ...data[intermediateIndex1],
+ x: avgX,
+ });
+ }
+ if (intermediateIndex2 !== startIndex && intermediateIndex2 !== lastIndex) {
+ decimated.push({
+ ...data[intermediateIndex2],
+ x: avgX
+ });
+ }
+ }
+ if (i > 0 && lastIndex !== startIndex) {
+ decimated.push(data[lastIndex]);
+ }
+ decimated.push(point);
+ prevX = truncX;
+ countX = 0;
+ minY = maxY = y;
+ minIndex = maxIndex = startIndex = i;
+ }
+ }
+ return decimated;
+}
+function cleanDecimatedDataset(dataset) {
+ if (dataset._decimated) {
+ const data = dataset._data;
+ delete dataset._decimated;
+ delete dataset._data;
+ Object.defineProperty(dataset, 'data', {value: data});
+ }
+}
+function cleanDecimatedData(chart) {
+ chart.data.datasets.forEach((dataset) => {
+ cleanDecimatedDataset(dataset);
+ });
+}
+function getStartAndCountOfVisiblePointsSimplified(meta, points) {
+ const pointCount = points.length;
+ let start = 0;
+ let count;
+ const {iScale} = meta;
+ const {min, max, minDefined, maxDefined} = iScale.getUserBounds();
+ if (minDefined) {
+ start = _limitValue(_lookupByKey(points, iScale.axis, min).lo, 0, pointCount - 1);
+ }
+ if (maxDefined) {
+ count = _limitValue(_lookupByKey(points, iScale.axis, max).hi + 1, start, pointCount) - start;
+ } else {
+ count = pointCount - start;
+ }
+ return {start, count};
+}
+var plugin_decimation = {
+ id: 'decimation',
+ defaults: {
+ algorithm: 'min-max',
+ enabled: false,
+ },
+ beforeElementsUpdate: (chart, args, options) => {
+ if (!options.enabled) {
+ cleanDecimatedData(chart);
+ return;
+ }
+ const availableWidth = chart.width;
+ chart.data.datasets.forEach((dataset, datasetIndex) => {
+ const {_data, indexAxis} = dataset;
+ const meta = chart.getDatasetMeta(datasetIndex);
+ const data = _data || dataset.data;
+ if (resolve([indexAxis, chart.options.indexAxis]) === 'y') {
+ return;
+ }
+ if (meta.type !== 'line') {
+ return;
+ }
+ const xAxis = chart.scales[meta.xAxisID];
+ if (xAxis.type !== 'linear' && xAxis.type !== 'time') {
+ return;
+ }
+ if (chart.options.parsing) {
+ return;
+ }
+ let {start, count} = getStartAndCountOfVisiblePointsSimplified(meta, data);
+ const threshold = options.threshold || 4 * availableWidth;
+ if (count <= threshold) {
+ cleanDecimatedDataset(dataset);
+ return;
+ }
+ if (isNullOrUndef(_data)) {
+ dataset._data = data;
+ delete dataset.data;
+ Object.defineProperty(dataset, 'data', {
+ configurable: true,
+ enumerable: true,
+ get: function() {
+ return this._decimated;
+ },
+ set: function(d) {
+ this._data = d;
+ }
+ });
+ }
+ let decimated;
+ switch (options.algorithm) {
+ case 'lttb':
+ decimated = lttbDecimation(data, start, count, availableWidth, options);
+ break;
+ case 'min-max':
+ decimated = minMaxDecimation(data, start, count, availableWidth);
+ break;
+ default:
+ throw new Error(`Unsupported decimation algorithm '${options.algorithm}'`);
+ }
+ dataset._decimated = decimated;
+ });
+ },
+ destroy(chart) {
+ cleanDecimatedData(chart);
+ }
+};
+
+function getLineByIndex(chart, index) {
+ const meta = chart.getDatasetMeta(index);
+ const visible = meta && chart.isDatasetVisible(index);
+ return visible ? meta.dataset : null;
+}
+function parseFillOption(line) {
+ const options = line.options;
+ const fillOption = options.fill;
+ let fill = valueOrDefault(fillOption && fillOption.target, fillOption);
+ if (fill === undefined) {
+ fill = !!options.backgroundColor;
+ }
+ if (fill === false || fill === null) {
+ return false;
+ }
+ if (fill === true) {
+ return 'origin';
+ }
+ return fill;
+}
+function decodeFill(line, index, count) {
+ const fill = parseFillOption(line);
+ if (isObject(fill)) {
+ return isNaN(fill.value) ? false : fill;
+ }
+ let target = parseFloat(fill);
+ if (isNumberFinite(target) && Math.floor(target) === target) {
+ if (fill[0] === '-' || fill[0] === '+') {
+ target = index + target;
+ }
+ if (target === index || target < 0 || target >= count) {
+ return false;
+ }
+ return target;
+ }
+ return ['origin', 'start', 'end', 'stack', 'shape'].indexOf(fill) >= 0 && fill;
+}
+function computeLinearBoundary(source) {
+ const {scale = {}, fill} = source;
+ let target = null;
+ let horizontal;
+ if (fill === 'start') {
+ target = scale.bottom;
+ } else if (fill === 'end') {
+ target = scale.top;
+ } else if (isObject(fill)) {
+ target = scale.getPixelForValue(fill.value);
+ } else if (scale.getBasePixel) {
+ target = scale.getBasePixel();
+ }
+ if (isNumberFinite(target)) {
+ horizontal = scale.isHorizontal();
+ return {
+ x: horizontal ? target : null,
+ y: horizontal ? null : target
+ };
+ }
+ return null;
+}
+class simpleArc {
+ constructor(opts) {
+ this.x = opts.x;
+ this.y = opts.y;
+ this.radius = opts.radius;
+ }
+ pathSegment(ctx, bounds, opts) {
+ const {x, y, radius} = this;
+ bounds = bounds || {start: 0, end: TAU};
+ ctx.arc(x, y, radius, bounds.end, bounds.start, true);
+ return !opts.bounds;
+ }
+ interpolate(point) {
+ const {x, y, radius} = this;
+ const angle = point.angle;
+ return {
+ x: x + Math.cos(angle) * radius,
+ y: y + Math.sin(angle) * radius,
+ angle
+ };
+ }
+}
+function computeCircularBoundary(source) {
+ const {scale, fill} = source;
+ const options = scale.options;
+ const length = scale.getLabels().length;
+ const target = [];
+ const start = options.reverse ? scale.max : scale.min;
+ const end = options.reverse ? scale.min : scale.max;
+ let i, center, value;
+ if (fill === 'start') {
+ value = start;
+ } else if (fill === 'end') {
+ value = end;
+ } else if (isObject(fill)) {
+ value = fill.value;
+ } else {
+ value = scale.getBaseValue();
+ }
+ if (options.grid.circular) {
+ center = scale.getPointPositionForValue(0, start);
+ return new simpleArc({
+ x: center.x,
+ y: center.y,
+ radius: scale.getDistanceFromCenterForValue(value)
+ });
+ }
+ for (i = 0; i < length; ++i) {
+ target.push(scale.getPointPositionForValue(i, value));
+ }
+ return target;
+}
+function computeBoundary(source) {
+ const scale = source.scale || {};
+ if (scale.getPointPositionForValue) {
+ return computeCircularBoundary(source);
+ }
+ return computeLinearBoundary(source);
+}
+function findSegmentEnd(start, end, points) {
+ for (;end > start; end--) {
+ const point = points[end];
+ if (!isNaN(point.x) && !isNaN(point.y)) {
+ break;
+ }
+ }
+ return end;
+}
+function pointsFromSegments(boundary, line) {
+ const {x = null, y = null} = boundary || {};
+ const linePoints = line.points;
+ const points = [];
+ line.segments.forEach(({start, end}) => {
+ end = findSegmentEnd(start, end, linePoints);
+ const first = linePoints[start];
+ const last = linePoints[end];
+ if (y !== null) {
+ points.push({x: first.x, y});
+ points.push({x: last.x, y});
+ } else if (x !== null) {
+ points.push({x, y: first.y});
+ points.push({x, y: last.y});
+ }
+ });
+ return points;
+}
+function buildStackLine(source) {
+ const {scale, index, line} = source;
+ const points = [];
+ const segments = line.segments;
+ const sourcePoints = line.points;
+ const linesBelow = getLinesBelow(scale, index);
+ linesBelow.push(createBoundaryLine({x: null, y: scale.bottom}, line));
+ for (let i = 0; i < segments.length; i++) {
+ const segment = segments[i];
+ for (let j = segment.start; j <= segment.end; j++) {
+ addPointsBelow(points, sourcePoints[j], linesBelow);
+ }
+ }
+ return new LineElement({points, options: {}});
+}
+function getLinesBelow(scale, index) {
+ const below = [];
+ const metas = scale.getMatchingVisibleMetas('line');
+ for (let i = 0; i < metas.length; i++) {
+ const meta = metas[i];
+ if (meta.index === index) {
+ break;
+ }
+ if (!meta.hidden) {
+ below.unshift(meta.dataset);
+ }
+ }
+ return below;
+}
+function addPointsBelow(points, sourcePoint, linesBelow) {
+ const postponed = [];
+ for (let j = 0; j < linesBelow.length; j++) {
+ const line = linesBelow[j];
+ const {first, last, point} = findPoint(line, sourcePoint, 'x');
+ if (!point || (first && last)) {
+ continue;
+ }
+ if (first) {
+ postponed.unshift(point);
+ } else {
+ points.push(point);
+ if (!last) {
+ break;
+ }
+ }
+ }
+ points.push(...postponed);
+}
+function findPoint(line, sourcePoint, property) {
+ const point = line.interpolate(sourcePoint, property);
+ if (!point) {
+ return {};
+ }
+ const pointValue = point[property];
+ const segments = line.segments;
+ const linePoints = line.points;
+ let first = false;
+ let last = false;
+ for (let i = 0; i < segments.length; i++) {
+ const segment = segments[i];
+ const firstValue = linePoints[segment.start][property];
+ const lastValue = linePoints[segment.end][property];
+ if (_isBetween(pointValue, firstValue, lastValue)) {
+ first = pointValue === firstValue;
+ last = pointValue === lastValue;
+ break;
+ }
+ }
+ return {first, last, point};
+}
+function getTarget(source) {
+ const {chart, fill, line} = source;
+ if (isNumberFinite(fill)) {
+ return getLineByIndex(chart, fill);
+ }
+ if (fill === 'stack') {
+ return buildStackLine(source);
+ }
+ if (fill === 'shape') {
+ return true;
+ }
+ const boundary = computeBoundary(source);
+ if (boundary instanceof simpleArc) {
+ return boundary;
+ }
+ return createBoundaryLine(boundary, line);
+}
+function createBoundaryLine(boundary, line) {
+ let points = [];
+ let _loop = false;
+ if (isArray(boundary)) {
+ _loop = true;
+ points = boundary;
+ } else {
+ points = pointsFromSegments(boundary, line);
+ }
+ return points.length ? new LineElement({
+ points,
+ options: {tension: 0},
+ _loop,
+ _fullLoop: _loop
+ }) : null;
+}
+function resolveTarget(sources, index, propagate) {
+ const source = sources[index];
+ let fill = source.fill;
+ const visited = [index];
+ let target;
+ if (!propagate) {
+ return fill;
+ }
+ while (fill !== false && visited.indexOf(fill) === -1) {
+ if (!isNumberFinite(fill)) {
+ return fill;
+ }
+ target = sources[fill];
+ if (!target) {
+ return false;
+ }
+ if (target.visible) {
+ return fill;
+ }
+ visited.push(fill);
+ fill = target.fill;
+ }
+ return false;
+}
+function _clip(ctx, target, clipY) {
+ const {segments, points} = target;
+ let first = true;
+ let lineLoop = false;
+ ctx.beginPath();
+ for (const segment of segments) {
+ const {start, end} = segment;
+ const firstPoint = points[start];
+ const lastPoint = points[findSegmentEnd(start, end, points)];
+ if (first) {
+ ctx.moveTo(firstPoint.x, firstPoint.y);
+ first = false;
+ } else {
+ ctx.lineTo(firstPoint.x, clipY);
+ ctx.lineTo(firstPoint.x, firstPoint.y);
+ }
+ lineLoop = !!target.pathSegment(ctx, segment, {move: lineLoop});
+ if (lineLoop) {
+ ctx.closePath();
+ } else {
+ ctx.lineTo(lastPoint.x, clipY);
+ }
+ }
+ ctx.lineTo(target.first().x, clipY);
+ ctx.closePath();
+ ctx.clip();
+}
+function getBounds(property, first, last, loop) {
+ if (loop) {
+ return;
+ }
+ let start = first[property];
+ let end = last[property];
+ if (property === 'angle') {
+ start = _normalizeAngle(start);
+ end = _normalizeAngle(end);
+ }
+ return {property, start, end};
+}
+function _getEdge(a, b, prop, fn) {
+ if (a && b) {
+ return fn(a[prop], b[prop]);
+ }
+ return a ? a[prop] : b ? b[prop] : 0;
+}
+function _segments(line, target, property) {
+ const segments = line.segments;
+ const points = line.points;
+ const tpoints = target.points;
+ const parts = [];
+ for (const segment of segments) {
+ let {start, end} = segment;
+ end = findSegmentEnd(start, end, points);
+ const bounds = getBounds(property, points[start], points[end], segment.loop);
+ if (!target.segments) {
+ parts.push({
+ source: segment,
+ target: bounds,
+ start: points[start],
+ end: points[end]
+ });
+ continue;
+ }
+ const targetSegments = _boundSegments(target, bounds);
+ for (const tgt of targetSegments) {
+ const subBounds = getBounds(property, tpoints[tgt.start], tpoints[tgt.end], tgt.loop);
+ const fillSources = _boundSegment(segment, points, subBounds);
+ for (const fillSource of fillSources) {
+ parts.push({
+ source: fillSource,
+ target: tgt,
+ start: {
+ [property]: _getEdge(bounds, subBounds, 'start', Math.max)
+ },
+ end: {
+ [property]: _getEdge(bounds, subBounds, 'end', Math.min)
+ }
+ });
+ }
+ }
+ }
+ return parts;
+}
+function clipBounds(ctx, scale, bounds) {
+ const {top, bottom} = scale.chart.chartArea;
+ const {property, start, end} = bounds || {};
+ if (property === 'x') {
+ ctx.beginPath();
+ ctx.rect(start, top, end - start, bottom - top);
+ ctx.clip();
+ }
+}
+function interpolatedLineTo(ctx, target, point, property) {
+ const interpolatedPoint = target.interpolate(point, property);
+ if (interpolatedPoint) {
+ ctx.lineTo(interpolatedPoint.x, interpolatedPoint.y);
+ }
+}
+function _fill(ctx, cfg) {
+ const {line, target, property, color, scale} = cfg;
+ const segments = _segments(line, target, property);
+ for (const {source: src, target: tgt, start, end} of segments) {
+ const {style: {backgroundColor = color} = {}} = src;
+ const notShape = target !== true;
+ ctx.save();
+ ctx.fillStyle = backgroundColor;
+ clipBounds(ctx, scale, notShape && getBounds(property, start, end));
+ ctx.beginPath();
+ const lineLoop = !!line.pathSegment(ctx, src);
+ let loop;
+ if (notShape) {
+ if (lineLoop) {
+ ctx.closePath();
+ } else {
+ interpolatedLineTo(ctx, target, end, property);
+ }
+ const targetLoop = !!target.pathSegment(ctx, tgt, {move: lineLoop, reverse: true});
+ loop = lineLoop && targetLoop;
+ if (!loop) {
+ interpolatedLineTo(ctx, target, start, property);
+ }
+ }
+ ctx.closePath();
+ ctx.fill(loop ? 'evenodd' : 'nonzero');
+ ctx.restore();
+ }
+}
+function doFill(ctx, cfg) {
+ const {line, target, above, below, area, scale} = cfg;
+ const property = line._loop ? 'angle' : cfg.axis;
+ ctx.save();
+ if (property === 'x' && below !== above) {
+ _clip(ctx, target, area.top);
+ _fill(ctx, {line, target, color: above, scale, property});
+ ctx.restore();
+ ctx.save();
+ _clip(ctx, target, area.bottom);
+ }
+ _fill(ctx, {line, target, color: below, scale, property});
+ ctx.restore();
+}
+function drawfill(ctx, source, area) {
+ const target = getTarget(source);
+ const {line, scale, axis} = source;
+ const lineOpts = line.options;
+ const fillOption = lineOpts.fill;
+ const color = lineOpts.backgroundColor;
+ const {above = color, below = color} = fillOption || {};
+ if (target && line.points.length) {
+ clipArea(ctx, area);
+ doFill(ctx, {line, target, above, below, area, scale, axis});
+ unclipArea(ctx);
+ }
+}
+var plugin_filler = {
+ id: 'filler',
+ afterDatasetsUpdate(chart, _args, options) {
+ const count = (chart.data.datasets || []).length;
+ const sources = [];
+ let meta, i, line, source;
+ for (i = 0; i < count; ++i) {
+ meta = chart.getDatasetMeta(i);
+ line = meta.dataset;
+ source = null;
+ if (line && line.options && line instanceof LineElement) {
+ source = {
+ visible: chart.isDatasetVisible(i),
+ index: i,
+ fill: decodeFill(line, i, count),
+ chart,
+ axis: meta.controller.options.indexAxis,
+ scale: meta.vScale,
+ line,
+ };
+ }
+ meta.$filler = source;
+ sources.push(source);
+ }
+ for (i = 0; i < count; ++i) {
+ source = sources[i];
+ if (!source || source.fill === false) {
+ continue;
+ }
+ source.fill = resolveTarget(sources, i, options.propagate);
+ }
+ },
+ beforeDraw(chart, _args, options) {
+ const draw = options.drawTime === 'beforeDraw';
+ const metasets = chart.getSortedVisibleDatasetMetas();
+ const area = chart.chartArea;
+ for (let i = metasets.length - 1; i >= 0; --i) {
+ const source = metasets[i].$filler;
+ if (!source) {
+ continue;
+ }
+ source.line.updateControlPoints(area, source.axis);
+ if (draw) {
+ drawfill(chart.ctx, source, area);
+ }
+ }
+ },
+ beforeDatasetsDraw(chart, _args, options) {
+ if (options.drawTime !== 'beforeDatasetsDraw') {
+ return;
+ }
+ const metasets = chart.getSortedVisibleDatasetMetas();
+ for (let i = metasets.length - 1; i >= 0; --i) {
+ const source = metasets[i].$filler;
+ if (source) {
+ drawfill(chart.ctx, source, chart.chartArea);
+ }
+ }
+ },
+ beforeDatasetDraw(chart, args, options) {
+ const source = args.meta.$filler;
+ if (!source || source.fill === false || options.drawTime !== 'beforeDatasetDraw') {
+ return;
+ }
+ drawfill(chart.ctx, source, chart.chartArea);
+ },
+ defaults: {
+ propagate: true,
+ drawTime: 'beforeDatasetDraw'
+ }
+};
+
+const getBoxSize = (labelOpts, fontSize) => {
+ let {boxHeight = fontSize, boxWidth = fontSize} = labelOpts;
+ if (labelOpts.usePointStyle) {
+ boxHeight = Math.min(boxHeight, fontSize);
+ boxWidth = Math.min(boxWidth, fontSize);
+ }
+ return {
+ boxWidth,
+ boxHeight,
+ itemHeight: Math.max(fontSize, boxHeight)
+ };
+};
+const itemsEqual = (a, b) => a !== null && b !== null && a.datasetIndex === b.datasetIndex && a.index === b.index;
+class Legend extends Element {
+ constructor(config) {
+ super();
+ this._added = false;
+ this.legendHitBoxes = [];
+ this._hoveredItem = null;
+ this.doughnutMode = false;
+ this.chart = config.chart;
+ this.options = config.options;
+ this.ctx = config.ctx;
+ this.legendItems = undefined;
+ this.columnSizes = undefined;
+ this.lineWidths = undefined;
+ this.maxHeight = undefined;
+ this.maxWidth = undefined;
+ this.top = undefined;
+ this.bottom = undefined;
+ this.left = undefined;
+ this.right = undefined;
+ this.height = undefined;
+ this.width = undefined;
+ this._margins = undefined;
+ this.position = undefined;
+ this.weight = undefined;
+ this.fullSize = undefined;
+ }
+ update(maxWidth, maxHeight, margins) {
+ this.maxWidth = maxWidth;
+ this.maxHeight = maxHeight;
+ this._margins = margins;
+ this.setDimensions();
+ this.buildLabels();
+ this.fit();
+ }
+ setDimensions() {
+ if (this.isHorizontal()) {
+ this.width = this.maxWidth;
+ this.left = this._margins.left;
+ this.right = this.width;
+ } else {
+ this.height = this.maxHeight;
+ this.top = this._margins.top;
+ this.bottom = this.height;
+ }
+ }
+ buildLabels() {
+ const labelOpts = this.options.labels || {};
+ let legendItems = callback(labelOpts.generateLabels, [this.chart], this) || [];
+ if (labelOpts.filter) {
+ legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data));
+ }
+ if (labelOpts.sort) {
+ legendItems = legendItems.sort((a, b) => labelOpts.sort(a, b, this.chart.data));
+ }
+ if (this.options.reverse) {
+ legendItems.reverse();
+ }
+ this.legendItems = legendItems;
+ }
+ fit() {
+ const {options, ctx} = this;
+ if (!options.display) {
+ this.width = this.height = 0;
+ return;
+ }
+ const labelOpts = options.labels;
+ const labelFont = toFont(labelOpts.font);
+ const fontSize = labelFont.size;
+ const titleHeight = this._computeTitleHeight();
+ const {boxWidth, itemHeight} = getBoxSize(labelOpts, fontSize);
+ let width, height;
+ ctx.font = labelFont.string;
+ if (this.isHorizontal()) {
+ width = this.maxWidth;
+ height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10;
+ } else {
+ height = this.maxHeight;
+ width = this._fitCols(titleHeight, fontSize, boxWidth, itemHeight) + 10;
+ }
+ this.width = Math.min(width, options.maxWidth || this.maxWidth);
+ this.height = Math.min(height, options.maxHeight || this.maxHeight);
+ }
+ _fitRows(titleHeight, fontSize, boxWidth, itemHeight) {
+ const {ctx, maxWidth, options: {labels: {padding}}} = this;
+ const hitboxes = this.legendHitBoxes = [];
+ const lineWidths = this.lineWidths = [0];
+ const lineHeight = itemHeight + padding;
+ let totalHeight = titleHeight;
+ ctx.textAlign = 'left';
+ ctx.textBaseline = 'middle';
+ let row = -1;
+ let top = -lineHeight;
+ this.legendItems.forEach((legendItem, i) => {
+ const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;
+ if (i === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) {
+ totalHeight += lineHeight;
+ lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0;
+ top += lineHeight;
+ row++;
+ }
+ hitboxes[i] = {left: 0, top, row, width: itemWidth, height: itemHeight};
+ lineWidths[lineWidths.length - 1] += itemWidth + padding;
+ });
+ return totalHeight;
+ }
+ _fitCols(titleHeight, fontSize, boxWidth, itemHeight) {
+ const {ctx, maxHeight, options: {labels: {padding}}} = this;
+ const hitboxes = this.legendHitBoxes = [];
+ const columnSizes = this.columnSizes = [];
+ const heightLimit = maxHeight - titleHeight;
+ let totalWidth = padding;
+ let currentColWidth = 0;
+ let currentColHeight = 0;
+ let left = 0;
+ let col = 0;
+ this.legendItems.forEach((legendItem, i) => {
+ const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;
+ if (i > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) {
+ totalWidth += currentColWidth + padding;
+ columnSizes.push({width: currentColWidth, height: currentColHeight});
+ left += currentColWidth + padding;
+ col++;
+ currentColWidth = currentColHeight = 0;
+ }
+ hitboxes[i] = {left, top: currentColHeight, col, width: itemWidth, height: itemHeight};
+ currentColWidth = Math.max(currentColWidth, itemWidth);
+ currentColHeight += itemHeight + padding;
+ });
+ totalWidth += currentColWidth;
+ columnSizes.push({width: currentColWidth, height: currentColHeight});
+ return totalWidth;
+ }
+ adjustHitBoxes() {
+ if (!this.options.display) {
+ return;
+ }
+ const titleHeight = this._computeTitleHeight();
+ const {legendHitBoxes: hitboxes, options: {align, labels: {padding}, rtl}} = this;
+ const rtlHelper = getRtlAdapter(rtl, this.left, this.width);
+ if (this.isHorizontal()) {
+ let row = 0;
+ let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
+ for (const hitbox of hitboxes) {
+ if (row !== hitbox.row) {
+ row = hitbox.row;
+ left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);
+ }
+ hitbox.top += this.top + titleHeight + padding;
+ hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width);
+ left += hitbox.width + padding;
+ }
+ } else {
+ let col = 0;
+ let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
+ for (const hitbox of hitboxes) {
+ if (hitbox.col !== col) {
+ col = hitbox.col;
+ top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);
+ }
+ hitbox.top = top;
+ hitbox.left += this.left + padding;
+ hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width);
+ top += hitbox.height + padding;
+ }
+ }
+ }
+ isHorizontal() {
+ return this.options.position === 'top' || this.options.position === 'bottom';
+ }
+ draw() {
+ if (this.options.display) {
+ const ctx = this.ctx;
+ clipArea(ctx, this);
+ this._draw();
+ unclipArea(ctx);
+ }
+ }
+ _draw() {
+ const {options: opts, columnSizes, lineWidths, ctx} = this;
+ const {align, labels: labelOpts} = opts;
+ const defaultColor = defaults.color;
+ const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
+ const labelFont = toFont(labelOpts.font);
+ const {color: fontColor, padding} = labelOpts;
+ const fontSize = labelFont.size;
+ const halfFontSize = fontSize / 2;
+ let cursor;
+ this.drawTitle();
+ ctx.textAlign = rtlHelper.textAlign('left');
+ ctx.textBaseline = 'middle';
+ ctx.lineWidth = 0.5;
+ ctx.font = labelFont.string;
+ const {boxWidth, boxHeight, itemHeight} = getBoxSize(labelOpts, fontSize);
+ const drawLegendBox = function(x, y, legendItem) {
+ if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) {
+ return;
+ }
+ ctx.save();
+ const lineWidth = valueOrDefault(legendItem.lineWidth, 1);
+ ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor);
+ ctx.lineCap = valueOrDefault(legendItem.lineCap, 'butt');
+ ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0);
+ ctx.lineJoin = valueOrDefault(legendItem.lineJoin, 'miter');
+ ctx.lineWidth = lineWidth;
+ ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor);
+ ctx.setLineDash(valueOrDefault(legendItem.lineDash, []));
+ if (labelOpts.usePointStyle) {
+ const drawOptions = {
+ radius: boxWidth * Math.SQRT2 / 2,
+ pointStyle: legendItem.pointStyle,
+ rotation: legendItem.rotation,
+ borderWidth: lineWidth
+ };
+ const centerX = rtlHelper.xPlus(x, boxWidth / 2);
+ const centerY = y + halfFontSize;
+ drawPoint(ctx, drawOptions, centerX, centerY);
+ } else {
+ const yBoxTop = y + Math.max((fontSize - boxHeight) / 2, 0);
+ const xBoxLeft = rtlHelper.leftForLtr(x, boxWidth);
+ const borderRadius = toTRBLCorners(legendItem.borderRadius);
+ ctx.beginPath();
+ if (Object.values(borderRadius).some(v => v !== 0)) {
+ addRoundedRectPath(ctx, {
+ x: xBoxLeft,
+ y: yBoxTop,
+ w: boxWidth,
+ h: boxHeight,
+ radius: borderRadius,
+ });
+ } else {
+ ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight);
+ }
+ ctx.fill();
+ if (lineWidth !== 0) {
+ ctx.stroke();
+ }
+ }
+ ctx.restore();
+ };
+ const fillText = function(x, y, legendItem) {
+ renderText(ctx, legendItem.text, x, y + (itemHeight / 2), labelFont, {
+ strikethrough: legendItem.hidden,
+ textAlign: rtlHelper.textAlign(legendItem.textAlign)
+ });
+ };
+ const isHorizontal = this.isHorizontal();
+ const titleHeight = this._computeTitleHeight();
+ if (isHorizontal) {
+ cursor = {
+ x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]),
+ y: this.top + padding + titleHeight,
+ line: 0
+ };
+ } else {
+ cursor = {
+ x: this.left + padding,
+ y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height),
+ line: 0
+ };
+ }
+ overrideTextDirection(this.ctx, opts.textDirection);
+ const lineHeight = itemHeight + padding;
+ this.legendItems.forEach((legendItem, i) => {
+ ctx.strokeStyle = legendItem.fontColor || fontColor;
+ ctx.fillStyle = legendItem.fontColor || fontColor;
+ const textWidth = ctx.measureText(legendItem.text).width;
+ const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign));
+ const width = boxWidth + halfFontSize + textWidth;
+ let x = cursor.x;
+ let y = cursor.y;
+ rtlHelper.setWidth(this.width);
+ if (isHorizontal) {
+ if (i > 0 && x + width + padding > this.right) {
+ y = cursor.y += lineHeight;
+ cursor.line++;
+ x = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]);
+ }
+ } else if (i > 0 && y + lineHeight > this.bottom) {
+ x = cursor.x = x + columnSizes[cursor.line].width + padding;
+ cursor.line++;
+ y = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height);
+ }
+ const realX = rtlHelper.x(x);
+ drawLegendBox(realX, y, legendItem);
+ x = _textX(textAlign, x + boxWidth + halfFontSize, isHorizontal ? x + width : this.right, opts.rtl);
+ fillText(rtlHelper.x(x), y, legendItem);
+ if (isHorizontal) {
+ cursor.x += width + padding;
+ } else {
+ cursor.y += lineHeight;
+ }
+ });
+ restoreTextDirection(this.ctx, opts.textDirection);
+ }
+ drawTitle() {
+ const opts = this.options;
+ const titleOpts = opts.title;
+ const titleFont = toFont(titleOpts.font);
+ const titlePadding = toPadding(titleOpts.padding);
+ if (!titleOpts.display) {
+ return;
+ }
+ const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);
+ const ctx = this.ctx;
+ const position = titleOpts.position;
+ const halfFontSize = titleFont.size / 2;
+ const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize;
+ let y;
+ let left = this.left;
+ let maxWidth = this.width;
+ if (this.isHorizontal()) {
+ maxWidth = Math.max(...this.lineWidths);
+ y = this.top + topPaddingPlusHalfFontSize;
+ left = _alignStartEnd(opts.align, left, this.right - maxWidth);
+ } else {
+ const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0);
+ y = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight());
+ }
+ const x = _alignStartEnd(position, left, left + maxWidth);
+ ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position));
+ ctx.textBaseline = 'middle';
+ ctx.strokeStyle = titleOpts.color;
+ ctx.fillStyle = titleOpts.color;
+ ctx.font = titleFont.string;
+ renderText(ctx, titleOpts.text, x, y, titleFont);
+ }
+ _computeTitleHeight() {
+ const titleOpts = this.options.title;
+ const titleFont = toFont(titleOpts.font);
+ const titlePadding = toPadding(titleOpts.padding);
+ return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0;
+ }
+ _getLegendItemAt(x, y) {
+ let i, hitBox, lh;
+ if (_isBetween(x, this.left, this.right)
+ && _isBetween(y, this.top, this.bottom)) {
+ lh = this.legendHitBoxes;
+ for (i = 0; i < lh.length; ++i) {
+ hitBox = lh[i];
+ if (_isBetween(x, hitBox.left, hitBox.left + hitBox.width)
+ && _isBetween(y, hitBox.top, hitBox.top + hitBox.height)) {
+ return this.legendItems[i];
+ }
+ }
+ }
+ return null;
+ }
+ handleEvent(e) {
+ const opts = this.options;
+ if (!isListened(e.type, opts)) {
+ return;
+ }
+ const hoveredItem = this._getLegendItemAt(e.x, e.y);
+ if (e.type === 'mousemove') {
+ const previous = this._hoveredItem;
+ const sameItem = itemsEqual(previous, hoveredItem);
+ if (previous && !sameItem) {
+ callback(opts.onLeave, [e, previous, this], this);
+ }
+ this._hoveredItem = hoveredItem;
+ if (hoveredItem && !sameItem) {
+ callback(opts.onHover, [e, hoveredItem, this], this);
+ }
+ } else if (hoveredItem) {
+ callback(opts.onClick, [e, hoveredItem, this], this);
+ }
+ }
+}
+function isListened(type, opts) {
+ if (type === 'mousemove' && (opts.onHover || opts.onLeave)) {
+ return true;
+ }
+ if (opts.onClick && (type === 'click' || type === 'mouseup')) {
+ return true;
+ }
+ return false;
+}
+var plugin_legend = {
+ id: 'legend',
+ _element: Legend,
+ start(chart, _args, options) {
+ const legend = chart.legend = new Legend({ctx: chart.ctx, options, chart});
+ layouts.configure(chart, legend, options);
+ layouts.addBox(chart, legend);
+ },
+ stop(chart) {
+ layouts.removeBox(chart, chart.legend);
+ delete chart.legend;
+ },
+ beforeUpdate(chart, _args, options) {
+ const legend = chart.legend;
+ layouts.configure(chart, legend, options);
+ legend.options = options;
+ },
+ afterUpdate(chart) {
+ const legend = chart.legend;
+ legend.buildLabels();
+ legend.adjustHitBoxes();
+ },
+ afterEvent(chart, args) {
+ if (!args.replay) {
+ chart.legend.handleEvent(args.event);
+ }
+ },
+ defaults: {
+ display: true,
+ position: 'top',
+ align: 'center',
+ fullSize: true,
+ reverse: false,
+ weight: 1000,
+ onClick(e, legendItem, legend) {
+ const index = legendItem.datasetIndex;
+ const ci = legend.chart;
+ if (ci.isDatasetVisible(index)) {
+ ci.hide(index);
+ legendItem.hidden = true;
+ } else {
+ ci.show(index);
+ legendItem.hidden = false;
+ }
+ },
+ onHover: null,
+ onLeave: null,
+ labels: {
+ color: (ctx) => ctx.chart.options.color,
+ boxWidth: 40,
+ padding: 10,
+ generateLabels(chart) {
+ const datasets = chart.data.datasets;
+ const {labels: {usePointStyle, pointStyle, textAlign, color}} = chart.legend.options;
+ return chart._getSortedDatasetMetas().map((meta) => {
+ const style = meta.controller.getStyle(usePointStyle ? 0 : undefined);
+ const borderWidth = toPadding(style.borderWidth);
+ return {
+ text: datasets[meta.index].label,
+ fillStyle: style.backgroundColor,
+ fontColor: color,
+ hidden: !meta.visible,
+ lineCap: style.borderCapStyle,
+ lineDash: style.borderDash,
+ lineDashOffset: style.borderDashOffset,
+ lineJoin: style.borderJoinStyle,
+ lineWidth: (borderWidth.width + borderWidth.height) / 4,
+ strokeStyle: style.borderColor,
+ pointStyle: pointStyle || style.pointStyle,
+ rotation: style.rotation,
+ textAlign: textAlign || style.textAlign,
+ borderRadius: 0,
+ datasetIndex: meta.index
+ };
+ }, this);
+ }
+ },
+ title: {
+ color: (ctx) => ctx.chart.options.color,
+ display: false,
+ position: 'center',
+ text: '',
+ }
+ },
+ descriptors: {
+ _scriptable: (name) => !name.startsWith('on'),
+ labels: {
+ _scriptable: (name) => !['generateLabels', 'filter', 'sort'].includes(name),
+ }
+ },
+};
+
+class Title extends Element {
+ constructor(config) {
+ super();
+ this.chart = config.chart;
+ this.options = config.options;
+ this.ctx = config.ctx;
+ this._padding = undefined;
+ this.top = undefined;
+ this.bottom = undefined;
+ this.left = undefined;
+ this.right = undefined;
+ this.width = undefined;
+ this.height = undefined;
+ this.position = undefined;
+ this.weight = undefined;
+ this.fullSize = undefined;
+ }
+ update(maxWidth, maxHeight) {
+ const opts = this.options;
+ this.left = 0;
+ this.top = 0;
+ if (!opts.display) {
+ this.width = this.height = this.right = this.bottom = 0;
+ return;
+ }
+ this.width = this.right = maxWidth;
+ this.height = this.bottom = maxHeight;
+ const lineCount = isArray(opts.text) ? opts.text.length : 1;
+ this._padding = toPadding(opts.padding);
+ const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height;
+ if (this.isHorizontal()) {
+ this.height = textSize;
+ } else {
+ this.width = textSize;
+ }
+ }
+ isHorizontal() {
+ const pos = this.options.position;
+ return pos === 'top' || pos === 'bottom';
+ }
+ _drawArgs(offset) {
+ const {top, left, bottom, right, options} = this;
+ const align = options.align;
+ let rotation = 0;
+ let maxWidth, titleX, titleY;
+ if (this.isHorizontal()) {
+ titleX = _alignStartEnd(align, left, right);
+ titleY = top + offset;
+ maxWidth = right - left;
+ } else {
+ if (options.position === 'left') {
+ titleX = left + offset;
+ titleY = _alignStartEnd(align, bottom, top);
+ rotation = PI * -0.5;
+ } else {
+ titleX = right - offset;
+ titleY = _alignStartEnd(align, top, bottom);
+ rotation = PI * 0.5;
+ }
+ maxWidth = bottom - top;
+ }
+ return {titleX, titleY, maxWidth, rotation};
+ }
+ draw() {
+ const ctx = this.ctx;
+ const opts = this.options;
+ if (!opts.display) {
+ return;
+ }
+ const fontOpts = toFont(opts.font);
+ const lineHeight = fontOpts.lineHeight;
+ const offset = lineHeight / 2 + this._padding.top;
+ const {titleX, titleY, maxWidth, rotation} = this._drawArgs(offset);
+ renderText(ctx, opts.text, 0, 0, fontOpts, {
+ color: opts.color,
+ maxWidth,
+ rotation,
+ textAlign: _toLeftRightCenter(opts.align),
+ textBaseline: 'middle',
+ translation: [titleX, titleY],
+ });
+ }
+}
+function createTitle(chart, titleOpts) {
+ const title = new Title({
+ ctx: chart.ctx,
+ options: titleOpts,
+ chart
+ });
+ layouts.configure(chart, title, titleOpts);
+ layouts.addBox(chart, title);
+ chart.titleBlock = title;
+}
+var plugin_title = {
+ id: 'title',
+ _element: Title,
+ start(chart, _args, options) {
+ createTitle(chart, options);
+ },
+ stop(chart) {
+ const titleBlock = chart.titleBlock;
+ layouts.removeBox(chart, titleBlock);
+ delete chart.titleBlock;
+ },
+ beforeUpdate(chart, _args, options) {
+ const title = chart.titleBlock;
+ layouts.configure(chart, title, options);
+ title.options = options;
+ },
+ defaults: {
+ align: 'center',
+ display: false,
+ font: {
+ weight: 'bold',
+ },
+ fullSize: true,
+ padding: 10,
+ position: 'top',
+ text: '',
+ weight: 2000
+ },
+ defaultRoutes: {
+ color: 'color'
+ },
+ descriptors: {
+ _scriptable: true,
+ _indexable: false,
+ },
+};
+
+const map = new WeakMap();
+var plugin_subtitle = {
+ id: 'subtitle',
+ start(chart, _args, options) {
+ const title = new Title({
+ ctx: chart.ctx,
+ options,
+ chart
+ });
+ layouts.configure(chart, title, options);
+ layouts.addBox(chart, title);
+ map.set(chart, title);
+ },
+ stop(chart) {
+ layouts.removeBox(chart, map.get(chart));
+ map.delete(chart);
+ },
+ beforeUpdate(chart, _args, options) {
+ const title = map.get(chart);
+ layouts.configure(chart, title, options);
+ title.options = options;
+ },
+ defaults: {
+ align: 'center',
+ display: false,
+ font: {
+ weight: 'normal',
+ },
+ fullSize: true,
+ padding: 0,
+ position: 'top',
+ text: '',
+ weight: 1500
+ },
+ defaultRoutes: {
+ color: 'color'
+ },
+ descriptors: {
+ _scriptable: true,
+ _indexable: false,
+ },
+};
+
+const positioners = {
+ average(items) {
+ if (!items.length) {
+ return false;
+ }
+ let i, len;
+ let x = 0;
+ let y = 0;
+ let count = 0;
+ for (i = 0, len = items.length; i < len; ++i) {
+ const el = items[i].element;
+ if (el && el.hasValue()) {
+ const pos = el.tooltipPosition();
+ x += pos.x;
+ y += pos.y;
+ ++count;
+ }
+ }
+ return {
+ x: x / count,
+ y: y / count
+ };
+ },
+ nearest(items, eventPosition) {
+ if (!items.length) {
+ return false;
+ }
+ let x = eventPosition.x;
+ let y = eventPosition.y;
+ let minDistance = Number.POSITIVE_INFINITY;
+ let i, len, nearestElement;
+ for (i = 0, len = items.length; i < len; ++i) {
+ const el = items[i].element;
+ if (el && el.hasValue()) {
+ const center = el.getCenterPoint();
+ const d = distanceBetweenPoints(eventPosition, center);
+ if (d < minDistance) {
+ minDistance = d;
+ nearestElement = el;
+ }
+ }
+ }
+ if (nearestElement) {
+ const tp = nearestElement.tooltipPosition();
+ x = tp.x;
+ y = tp.y;
+ }
+ return {
+ x,
+ y
+ };
+ }
+};
+function pushOrConcat(base, toPush) {
+ if (toPush) {
+ if (isArray(toPush)) {
+ Array.prototype.push.apply(base, toPush);
+ } else {
+ base.push(toPush);
+ }
+ }
+ return base;
+}
+function splitNewlines(str) {
+ if ((typeof str === 'string' || str instanceof String) && str.indexOf('\n') > -1) {
+ return str.split('\n');
+ }
+ return str;
+}
+function createTooltipItem(chart, item) {
+ const {element, datasetIndex, index} = item;
+ const controller = chart.getDatasetMeta(datasetIndex).controller;
+ const {label, value} = controller.getLabelAndValue(index);
+ return {
+ chart,
+ label,
+ parsed: controller.getParsed(index),
+ raw: chart.data.datasets[datasetIndex].data[index],
+ formattedValue: value,
+ dataset: controller.getDataset(),
+ dataIndex: index,
+ datasetIndex,
+ element
+ };
+}
+function getTooltipSize(tooltip, options) {
+ const ctx = tooltip.chart.ctx;
+ const {body, footer, title} = tooltip;
+ const {boxWidth, boxHeight} = options;
+ const bodyFont = toFont(options.bodyFont);
+ const titleFont = toFont(options.titleFont);
+ const footerFont = toFont(options.footerFont);
+ const titleLineCount = title.length;
+ const footerLineCount = footer.length;
+ const bodyLineItemCount = body.length;
+ const padding = toPadding(options.padding);
+ let height = padding.height;
+ let width = 0;
+ let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);
+ combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;
+ if (titleLineCount) {
+ height += titleLineCount * titleFont.lineHeight
+ + (titleLineCount - 1) * options.titleSpacing
+ + options.titleMarginBottom;
+ }
+ if (combinedBodyLength) {
+ const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;
+ height += bodyLineItemCount * bodyLineHeight
+ + (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight
+ + (combinedBodyLength - 1) * options.bodySpacing;
+ }
+ if (footerLineCount) {
+ height += options.footerMarginTop
+ + footerLineCount * footerFont.lineHeight
+ + (footerLineCount - 1) * options.footerSpacing;
+ }
+ let widthPadding = 0;
+ const maxLineWidth = function(line) {
+ width = Math.max(width, ctx.measureText(line).width + widthPadding);
+ };
+ ctx.save();
+ ctx.font = titleFont.string;
+ each(tooltip.title, maxLineWidth);
+ ctx.font = bodyFont.string;
+ each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);
+ widthPadding = options.displayColors ? (boxWidth + 2 + options.boxPadding) : 0;
+ each(body, (bodyItem) => {
+ each(bodyItem.before, maxLineWidth);
+ each(bodyItem.lines, maxLineWidth);
+ each(bodyItem.after, maxLineWidth);
+ });
+ widthPadding = 0;
+ ctx.font = footerFont.string;
+ each(tooltip.footer, maxLineWidth);
+ ctx.restore();
+ width += padding.width;
+ return {width, height};
+}
+function determineYAlign(chart, size) {
+ const {y, height} = size;
+ if (y < height / 2) {
+ return 'top';
+ } else if (y > (chart.height - height / 2)) {
+ return 'bottom';
+ }
+ return 'center';
+}
+function doesNotFitWithAlign(xAlign, chart, options, size) {
+ const {x, width} = size;
+ const caret = options.caretSize + options.caretPadding;
+ if (xAlign === 'left' && x + width + caret > chart.width) {
+ return true;
+ }
+ if (xAlign === 'right' && x - width - caret < 0) {
+ return true;
+ }
+}
+function determineXAlign(chart, options, size, yAlign) {
+ const {x, width} = size;
+ const {width: chartWidth, chartArea: {left, right}} = chart;
+ let xAlign = 'center';
+ if (yAlign === 'center') {
+ xAlign = x <= (left + right) / 2 ? 'left' : 'right';
+ } else if (x <= width / 2) {
+ xAlign = 'left';
+ } else if (x >= chartWidth - width / 2) {
+ xAlign = 'right';
+ }
+ if (doesNotFitWithAlign(xAlign, chart, options, size)) {
+ xAlign = 'center';
+ }
+ return xAlign;
+}
+function determineAlignment(chart, options, size) {
+ const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);
+ return {
+ xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),
+ yAlign
+ };
+}
+function alignX(size, xAlign) {
+ let {x, width} = size;
+ if (xAlign === 'right') {
+ x -= width;
+ } else if (xAlign === 'center') {
+ x -= (width / 2);
+ }
+ return x;
+}
+function alignY(size, yAlign, paddingAndSize) {
+ let {y, height} = size;
+ if (yAlign === 'top') {
+ y += paddingAndSize;
+ } else if (yAlign === 'bottom') {
+ y -= height + paddingAndSize;
+ } else {
+ y -= (height / 2);
+ }
+ return y;
+}
+function getBackgroundPoint(options, size, alignment, chart) {
+ const {caretSize, caretPadding, cornerRadius} = options;
+ const {xAlign, yAlign} = alignment;
+ const paddingAndSize = caretSize + caretPadding;
+ const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);
+ let x = alignX(size, xAlign);
+ const y = alignY(size, yAlign, paddingAndSize);
+ if (yAlign === 'center') {
+ if (xAlign === 'left') {
+ x += paddingAndSize;
+ } else if (xAlign === 'right') {
+ x -= paddingAndSize;
+ }
+ } else if (xAlign === 'left') {
+ x -= Math.max(topLeft, bottomLeft) + caretSize;
+ } else if (xAlign === 'right') {
+ x += Math.max(topRight, bottomRight) + caretSize;
+ }
+ return {
+ x: _limitValue(x, 0, chart.width - size.width),
+ y: _limitValue(y, 0, chart.height - size.height)
+ };
+}
+function getAlignedX(tooltip, align, options) {
+ const padding = toPadding(options.padding);
+ return align === 'center'
+ ? tooltip.x + tooltip.width / 2
+ : align === 'right'
+ ? tooltip.x + tooltip.width - padding.right
+ : tooltip.x + padding.left;
+}
+function getBeforeAfterBodyLines(callback) {
+ return pushOrConcat([], splitNewlines(callback));
+}
+function createTooltipContext(parent, tooltip, tooltipItems) {
+ return createContext(parent, {
+ tooltip,
+ tooltipItems,
+ type: 'tooltip'
+ });
+}
+function overrideCallbacks(callbacks, context) {
+ const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;
+ return override ? callbacks.override(override) : callbacks;
+}
+class Tooltip extends Element {
+ constructor(config) {
+ super();
+ this.opacity = 0;
+ this._active = [];
+ this._eventPosition = undefined;
+ this._size = undefined;
+ this._cachedAnimations = undefined;
+ this._tooltipItems = [];
+ this.$animations = undefined;
+ this.$context = undefined;
+ this.chart = config.chart || config._chart;
+ this._chart = this.chart;
+ this.options = config.options;
+ this.dataPoints = undefined;
+ this.title = undefined;
+ this.beforeBody = undefined;
+ this.body = undefined;
+ this.afterBody = undefined;
+ this.footer = undefined;
+ this.xAlign = undefined;
+ this.yAlign = undefined;
+ this.x = undefined;
+ this.y = undefined;
+ this.height = undefined;
+ this.width = undefined;
+ this.caretX = undefined;
+ this.caretY = undefined;
+ this.labelColors = undefined;
+ this.labelPointStyles = undefined;
+ this.labelTextColors = undefined;
+ }
+ initialize(options) {
+ this.options = options;
+ this._cachedAnimations = undefined;
+ this.$context = undefined;
+ }
+ _resolveAnimations() {
+ const cached = this._cachedAnimations;
+ if (cached) {
+ return cached;
+ }
+ const chart = this.chart;
+ const options = this.options.setContext(this.getContext());
+ const opts = options.enabled && chart.options.animation && options.animations;
+ const animations = new Animations(this.chart, opts);
+ if (opts._cacheable) {
+ this._cachedAnimations = Object.freeze(animations);
+ }
+ return animations;
+ }
+ getContext() {
+ return this.$context ||
+ (this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));
+ }
+ getTitle(context, options) {
+ const {callbacks} = options;
+ const beforeTitle = callbacks.beforeTitle.apply(this, [context]);
+ const title = callbacks.title.apply(this, [context]);
+ const afterTitle = callbacks.afterTitle.apply(this, [context]);
+ let lines = [];
+ lines = pushOrConcat(lines, splitNewlines(beforeTitle));
+ lines = pushOrConcat(lines, splitNewlines(title));
+ lines = pushOrConcat(lines, splitNewlines(afterTitle));
+ return lines;
+ }
+ getBeforeBody(tooltipItems, options) {
+ return getBeforeAfterBodyLines(options.callbacks.beforeBody.apply(this, [tooltipItems]));
+ }
+ getBody(tooltipItems, options) {
+ const {callbacks} = options;
+ const bodyItems = [];
+ each(tooltipItems, (context) => {
+ const bodyItem = {
+ before: [],
+ lines: [],
+ after: []
+ };
+ const scoped = overrideCallbacks(callbacks, context);
+ pushOrConcat(bodyItem.before, splitNewlines(scoped.beforeLabel.call(this, context)));
+ pushOrConcat(bodyItem.lines, scoped.label.call(this, context));
+ pushOrConcat(bodyItem.after, splitNewlines(scoped.afterLabel.call(this, context)));
+ bodyItems.push(bodyItem);
+ });
+ return bodyItems;
+ }
+ getAfterBody(tooltipItems, options) {
+ return getBeforeAfterBodyLines(options.callbacks.afterBody.apply(this, [tooltipItems]));
+ }
+ getFooter(tooltipItems, options) {
+ const {callbacks} = options;
+ const beforeFooter = callbacks.beforeFooter.apply(this, [tooltipItems]);
+ const footer = callbacks.footer.apply(this, [tooltipItems]);
+ const afterFooter = callbacks.afterFooter.apply(this, [tooltipItems]);
+ let lines = [];
+ lines = pushOrConcat(lines, splitNewlines(beforeFooter));
+ lines = pushOrConcat(lines, splitNewlines(footer));
+ lines = pushOrConcat(lines, splitNewlines(afterFooter));
+ return lines;
+ }
+ _createItems(options) {
+ const active = this._active;
+ const data = this.chart.data;
+ const labelColors = [];
+ const labelPointStyles = [];
+ const labelTextColors = [];
+ let tooltipItems = [];
+ let i, len;
+ for (i = 0, len = active.length; i < len; ++i) {
+ tooltipItems.push(createTooltipItem(this.chart, active[i]));
+ }
+ if (options.filter) {
+ tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));
+ }
+ if (options.itemSort) {
+ tooltipItems = tooltipItems.sort((a, b) => options.itemSort(a, b, data));
+ }
+ each(tooltipItems, (context) => {
+ const scoped = overrideCallbacks(options.callbacks, context);
+ labelColors.push(scoped.labelColor.call(this, context));
+ labelPointStyles.push(scoped.labelPointStyle.call(this, context));
+ labelTextColors.push(scoped.labelTextColor.call(this, context));
+ });
+ this.labelColors = labelColors;
+ this.labelPointStyles = labelPointStyles;
+ this.labelTextColors = labelTextColors;
+ this.dataPoints = tooltipItems;
+ return tooltipItems;
+ }
+ update(changed, replay) {
+ const options = this.options.setContext(this.getContext());
+ const active = this._active;
+ let properties;
+ let tooltipItems = [];
+ if (!active.length) {
+ if (this.opacity !== 0) {
+ properties = {
+ opacity: 0
+ };
+ }
+ } else {
+ const position = positioners[options.position].call(this, active, this._eventPosition);
+ tooltipItems = this._createItems(options);
+ this.title = this.getTitle(tooltipItems, options);
+ this.beforeBody = this.getBeforeBody(tooltipItems, options);
+ this.body = this.getBody(tooltipItems, options);
+ this.afterBody = this.getAfterBody(tooltipItems, options);
+ this.footer = this.getFooter(tooltipItems, options);
+ const size = this._size = getTooltipSize(this, options);
+ const positionAndSize = Object.assign({}, position, size);
+ const alignment = determineAlignment(this.chart, options, positionAndSize);
+ const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);
+ this.xAlign = alignment.xAlign;
+ this.yAlign = alignment.yAlign;
+ properties = {
+ opacity: 1,
+ x: backgroundPoint.x,
+ y: backgroundPoint.y,
+ width: size.width,
+ height: size.height,
+ caretX: position.x,
+ caretY: position.y
+ };
+ }
+ this._tooltipItems = tooltipItems;
+ this.$context = undefined;
+ if (properties) {
+ this._resolveAnimations().update(this, properties);
+ }
+ if (changed && options.external) {
+ options.external.call(this, {chart: this.chart, tooltip: this, replay});
+ }
+ }
+ drawCaret(tooltipPoint, ctx, size, options) {
+ const caretPosition = this.getCaretPosition(tooltipPoint, size, options);
+ ctx.lineTo(caretPosition.x1, caretPosition.y1);
+ ctx.lineTo(caretPosition.x2, caretPosition.y2);
+ ctx.lineTo(caretPosition.x3, caretPosition.y3);
+ }
+ getCaretPosition(tooltipPoint, size, options) {
+ const {xAlign, yAlign} = this;
+ const {caretSize, cornerRadius} = options;
+ const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);
+ const {x: ptX, y: ptY} = tooltipPoint;
+ const {width, height} = size;
+ let x1, x2, x3, y1, y2, y3;
+ if (yAlign === 'center') {
+ y2 = ptY + (height / 2);
+ if (xAlign === 'left') {
+ x1 = ptX;
+ x2 = x1 - caretSize;
+ y1 = y2 + caretSize;
+ y3 = y2 - caretSize;
+ } else {
+ x1 = ptX + width;
+ x2 = x1 + caretSize;
+ y1 = y2 - caretSize;
+ y3 = y2 + caretSize;
+ }
+ x3 = x1;
+ } else {
+ if (xAlign === 'left') {
+ x2 = ptX + Math.max(topLeft, bottomLeft) + (caretSize);
+ } else if (xAlign === 'right') {
+ x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;
+ } else {
+ x2 = this.caretX;
+ }
+ if (yAlign === 'top') {
+ y1 = ptY;
+ y2 = y1 - caretSize;
+ x1 = x2 - caretSize;
+ x3 = x2 + caretSize;
+ } else {
+ y1 = ptY + height;
+ y2 = y1 + caretSize;
+ x1 = x2 + caretSize;
+ x3 = x2 - caretSize;
+ }
+ y3 = y1;
+ }
+ return {x1, x2, x3, y1, y2, y3};
+ }
+ drawTitle(pt, ctx, options) {
+ const title = this.title;
+ const length = title.length;
+ let titleFont, titleSpacing, i;
+ if (length) {
+ const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
+ pt.x = getAlignedX(this, options.titleAlign, options);
+ ctx.textAlign = rtlHelper.textAlign(options.titleAlign);
+ ctx.textBaseline = 'middle';
+ titleFont = toFont(options.titleFont);
+ titleSpacing = options.titleSpacing;
+ ctx.fillStyle = options.titleColor;
+ ctx.font = titleFont.string;
+ for (i = 0; i < length; ++i) {
+ ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2);
+ pt.y += titleFont.lineHeight + titleSpacing;
+ if (i + 1 === length) {
+ pt.y += options.titleMarginBottom - titleSpacing;
+ }
+ }
+ }
+ }
+ _drawColorBox(ctx, pt, i, rtlHelper, options) {
+ const labelColors = this.labelColors[i];
+ const labelPointStyle = this.labelPointStyles[i];
+ const {boxHeight, boxWidth, boxPadding} = options;
+ const bodyFont = toFont(options.bodyFont);
+ const colorX = getAlignedX(this, 'left', options);
+ const rtlColorX = rtlHelper.x(colorX);
+ const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;
+ const colorY = pt.y + yOffSet;
+ if (options.usePointStyle) {
+ const drawOptions = {
+ radius: Math.min(boxWidth, boxHeight) / 2,
+ pointStyle: labelPointStyle.pointStyle,
+ rotation: labelPointStyle.rotation,
+ borderWidth: 1
+ };
+ const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;
+ const centerY = colorY + boxHeight / 2;
+ ctx.strokeStyle = options.multiKeyBackground;
+ ctx.fillStyle = options.multiKeyBackground;
+ drawPoint(ctx, drawOptions, centerX, centerY);
+ ctx.strokeStyle = labelColors.borderColor;
+ ctx.fillStyle = labelColors.backgroundColor;
+ drawPoint(ctx, drawOptions, centerX, centerY);
+ } else {
+ ctx.lineWidth = labelColors.borderWidth || 1;
+ ctx.strokeStyle = labelColors.borderColor;
+ ctx.setLineDash(labelColors.borderDash || []);
+ ctx.lineDashOffset = labelColors.borderDashOffset || 0;
+ const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth - boxPadding);
+ const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - boxPadding - 2);
+ const borderRadius = toTRBLCorners(labelColors.borderRadius);
+ if (Object.values(borderRadius).some(v => v !== 0)) {
+ ctx.beginPath();
+ ctx.fillStyle = options.multiKeyBackground;
+ addRoundedRectPath(ctx, {
+ x: outerX,
+ y: colorY,
+ w: boxWidth,
+ h: boxHeight,
+ radius: borderRadius,
+ });
+ ctx.fill();
+ ctx.stroke();
+ ctx.fillStyle = labelColors.backgroundColor;
+ ctx.beginPath();
+ addRoundedRectPath(ctx, {
+ x: innerX,
+ y: colorY + 1,
+ w: boxWidth - 2,
+ h: boxHeight - 2,
+ radius: borderRadius,
+ });
+ ctx.fill();
+ } else {
+ ctx.fillStyle = options.multiKeyBackground;
+ ctx.fillRect(outerX, colorY, boxWidth, boxHeight);
+ ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);
+ ctx.fillStyle = labelColors.backgroundColor;
+ ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);
+ }
+ }
+ ctx.fillStyle = this.labelTextColors[i];
+ }
+ drawBody(pt, ctx, options) {
+ const {body} = this;
+ const {bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding} = options;
+ const bodyFont = toFont(options.bodyFont);
+ let bodyLineHeight = bodyFont.lineHeight;
+ let xLinePadding = 0;
+ const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
+ const fillLineOfText = function(line) {
+ ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2);
+ pt.y += bodyLineHeight + bodySpacing;
+ };
+ const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);
+ let bodyItem, textColor, lines, i, j, ilen, jlen;
+ ctx.textAlign = bodyAlign;
+ ctx.textBaseline = 'middle';
+ ctx.font = bodyFont.string;
+ pt.x = getAlignedX(this, bodyAlignForCalculation, options);
+ ctx.fillStyle = options.bodyColor;
+ each(this.beforeBody, fillLineOfText);
+ xLinePadding = displayColors && bodyAlignForCalculation !== 'right'
+ ? bodyAlign === 'center' ? (boxWidth / 2 + boxPadding) : (boxWidth + 2 + boxPadding)
+ : 0;
+ for (i = 0, ilen = body.length; i < ilen; ++i) {
+ bodyItem = body[i];
+ textColor = this.labelTextColors[i];
+ ctx.fillStyle = textColor;
+ each(bodyItem.before, fillLineOfText);
+ lines = bodyItem.lines;
+ if (displayColors && lines.length) {
+ this._drawColorBox(ctx, pt, i, rtlHelper, options);
+ bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);
+ }
+ for (j = 0, jlen = lines.length; j < jlen; ++j) {
+ fillLineOfText(lines[j]);
+ bodyLineHeight = bodyFont.lineHeight;
+ }
+ each(bodyItem.after, fillLineOfText);
+ }
+ xLinePadding = 0;
+ bodyLineHeight = bodyFont.lineHeight;
+ each(this.afterBody, fillLineOfText);
+ pt.y -= bodySpacing;
+ }
+ drawFooter(pt, ctx, options) {
+ const footer = this.footer;
+ const length = footer.length;
+ let footerFont, i;
+ if (length) {
+ const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);
+ pt.x = getAlignedX(this, options.footerAlign, options);
+ pt.y += options.footerMarginTop;
+ ctx.textAlign = rtlHelper.textAlign(options.footerAlign);
+ ctx.textBaseline = 'middle';
+ footerFont = toFont(options.footerFont);
+ ctx.fillStyle = options.footerColor;
+ ctx.font = footerFont.string;
+ for (i = 0; i < length; ++i) {
+ ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2);
+ pt.y += footerFont.lineHeight + options.footerSpacing;
+ }
+ }
+ }
+ drawBackground(pt, ctx, tooltipSize, options) {
+ const {xAlign, yAlign} = this;
+ const {x, y} = pt;
+ const {width, height} = tooltipSize;
+ const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(options.cornerRadius);
+ ctx.fillStyle = options.backgroundColor;
+ ctx.strokeStyle = options.borderColor;
+ ctx.lineWidth = options.borderWidth;
+ ctx.beginPath();
+ ctx.moveTo(x + topLeft, y);
+ if (yAlign === 'top') {
+ this.drawCaret(pt, ctx, tooltipSize, options);
+ }
+ ctx.lineTo(x + width - topRight, y);
+ ctx.quadraticCurveTo(x + width, y, x + width, y + topRight);
+ if (yAlign === 'center' && xAlign === 'right') {
+ this.drawCaret(pt, ctx, tooltipSize, options);
+ }
+ ctx.lineTo(x + width, y + height - bottomRight);
+ ctx.quadraticCurveTo(x + width, y + height, x + width - bottomRight, y + height);
+ if (yAlign === 'bottom') {
+ this.drawCaret(pt, ctx, tooltipSize, options);
+ }
+ ctx.lineTo(x + bottomLeft, y + height);
+ ctx.quadraticCurveTo(x, y + height, x, y + height - bottomLeft);
+ if (yAlign === 'center' && xAlign === 'left') {
+ this.drawCaret(pt, ctx, tooltipSize, options);
+ }
+ ctx.lineTo(x, y + topLeft);
+ ctx.quadraticCurveTo(x, y, x + topLeft, y);
+ ctx.closePath();
+ ctx.fill();
+ if (options.borderWidth > 0) {
+ ctx.stroke();
+ }
+ }
+ _updateAnimationTarget(options) {
+ const chart = this.chart;
+ const anims = this.$animations;
+ const animX = anims && anims.x;
+ const animY = anims && anims.y;
+ if (animX || animY) {
+ const position = positioners[options.position].call(this, this._active, this._eventPosition);
+ if (!position) {
+ return;
+ }
+ const size = this._size = getTooltipSize(this, options);
+ const positionAndSize = Object.assign({}, position, this._size);
+ const alignment = determineAlignment(chart, options, positionAndSize);
+ const point = getBackgroundPoint(options, positionAndSize, alignment, chart);
+ if (animX._to !== point.x || animY._to !== point.y) {
+ this.xAlign = alignment.xAlign;
+ this.yAlign = alignment.yAlign;
+ this.width = size.width;
+ this.height = size.height;
+ this.caretX = position.x;
+ this.caretY = position.y;
+ this._resolveAnimations().update(this, point);
+ }
+ }
+ }
+ draw(ctx) {
+ const options = this.options.setContext(this.getContext());
+ let opacity = this.opacity;
+ if (!opacity) {
+ return;
+ }
+ this._updateAnimationTarget(options);
+ const tooltipSize = {
+ width: this.width,
+ height: this.height
+ };
+ const pt = {
+ x: this.x,
+ y: this.y
+ };
+ opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;
+ const padding = toPadding(options.padding);
+ const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;
+ if (options.enabled && hasTooltipContent) {
+ ctx.save();
+ ctx.globalAlpha = opacity;
+ this.drawBackground(pt, ctx, tooltipSize, options);
+ overrideTextDirection(ctx, options.textDirection);
+ pt.y += padding.top;
+ this.drawTitle(pt, ctx, options);
+ this.drawBody(pt, ctx, options);
+ this.drawFooter(pt, ctx, options);
+ restoreTextDirection(ctx, options.textDirection);
+ ctx.restore();
+ }
+ }
+ getActiveElements() {
+ return this._active || [];
+ }
+ setActiveElements(activeElements, eventPosition) {
+ const lastActive = this._active;
+ const active = activeElements.map(({datasetIndex, index}) => {
+ const meta = this.chart.getDatasetMeta(datasetIndex);
+ if (!meta) {
+ throw new Error('Cannot find a dataset at index ' + datasetIndex);
+ }
+ return {
+ datasetIndex,
+ element: meta.data[index],
+ index,
+ };
+ });
+ const changed = !_elementsEqual(lastActive, active);
+ const positionChanged = this._positionChanged(active, eventPosition);
+ if (changed || positionChanged) {
+ this._active = active;
+ this._eventPosition = eventPosition;
+ this._ignoreReplayEvents = true;
+ this.update(true);
+ }
+ }
+ handleEvent(e, replay, inChartArea = true) {
+ if (replay && this._ignoreReplayEvents) {
+ return false;
+ }
+ this._ignoreReplayEvents = false;
+ const options = this.options;
+ const lastActive = this._active || [];
+ const active = this._getActiveElements(e, lastActive, replay, inChartArea);
+ const positionChanged = this._positionChanged(active, e);
+ const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;
+ if (changed) {
+ this._active = active;
+ if (options.enabled || options.external) {
+ this._eventPosition = {
+ x: e.x,
+ y: e.y
+ };
+ this.update(true, replay);
+ }
+ }
+ return changed;
+ }
+ _getActiveElements(e, lastActive, replay, inChartArea) {
+ const options = this.options;
+ if (e.type === 'mouseout') {
+ return [];
+ }
+ if (!inChartArea) {
+ return lastActive;
+ }
+ const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay);
+ if (options.reverse) {
+ active.reverse();
+ }
+ return active;
+ }
+ _positionChanged(active, e) {
+ const {caretX, caretY, options} = this;
+ const position = positioners[options.position].call(this, active, e);
+ return position !== false && (caretX !== position.x || caretY !== position.y);
+ }
+}
+Tooltip.positioners = positioners;
+var plugin_tooltip = {
+ id: 'tooltip',
+ _element: Tooltip,
+ positioners,
+ afterInit(chart, _args, options) {
+ if (options) {
+ chart.tooltip = new Tooltip({chart, options});
+ }
+ },
+ beforeUpdate(chart, _args, options) {
+ if (chart.tooltip) {
+ chart.tooltip.initialize(options);
+ }
+ },
+ reset(chart, _args, options) {
+ if (chart.tooltip) {
+ chart.tooltip.initialize(options);
+ }
+ },
+ afterDraw(chart) {
+ const tooltip = chart.tooltip;
+ const args = {
+ tooltip
+ };
+ if (chart.notifyPlugins('beforeTooltipDraw', args) === false) {
+ return;
+ }
+ if (tooltip) {
+ tooltip.draw(chart.ctx);
+ }
+ chart.notifyPlugins('afterTooltipDraw', args);
+ },
+ afterEvent(chart, args) {
+ if (chart.tooltip) {
+ const useFinalPosition = args.replay;
+ if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {
+ args.changed = true;
+ }
+ }
+ },
+ defaults: {
+ enabled: true,
+ external: null,
+ position: 'average',
+ backgroundColor: 'rgba(0,0,0,0.8)',
+ titleColor: '#fff',
+ titleFont: {
+ weight: 'bold',
+ },
+ titleSpacing: 2,
+ titleMarginBottom: 6,
+ titleAlign: 'left',
+ bodyColor: '#fff',
+ bodySpacing: 2,
+ bodyFont: {
+ },
+ bodyAlign: 'left',
+ footerColor: '#fff',
+ footerSpacing: 2,
+ footerMarginTop: 6,
+ footerFont: {
+ weight: 'bold',
+ },
+ footerAlign: 'left',
+ padding: 6,
+ caretPadding: 2,
+ caretSize: 5,
+ cornerRadius: 6,
+ boxHeight: (ctx, opts) => opts.bodyFont.size,
+ boxWidth: (ctx, opts) => opts.bodyFont.size,
+ multiKeyBackground: '#fff',
+ displayColors: true,
+ boxPadding: 0,
+ borderColor: 'rgba(0,0,0,0)',
+ borderWidth: 0,
+ animation: {
+ duration: 400,
+ easing: 'easeOutQuart',
+ },
+ animations: {
+ numbers: {
+ type: 'number',
+ properties: ['x', 'y', 'width', 'height', 'caretX', 'caretY'],
+ },
+ opacity: {
+ easing: 'linear',
+ duration: 200
+ }
+ },
+ callbacks: {
+ beforeTitle: noop,
+ title(tooltipItems) {
+ if (tooltipItems.length > 0) {
+ const item = tooltipItems[0];
+ const labels = item.chart.data.labels;
+ const labelCount = labels ? labels.length : 0;
+ if (this && this.options && this.options.mode === 'dataset') {
+ return item.dataset.label || '';
+ } else if (item.label) {
+ return item.label;
+ } else if (labelCount > 0 && item.dataIndex < labelCount) {
+ return labels[item.dataIndex];
+ }
+ }
+ return '';
+ },
+ afterTitle: noop,
+ beforeBody: noop,
+ beforeLabel: noop,
+ label(tooltipItem) {
+ if (this && this.options && this.options.mode === 'dataset') {
+ return tooltipItem.label + ': ' + tooltipItem.formattedValue || tooltipItem.formattedValue;
+ }
+ let label = tooltipItem.dataset.label || '';
+ if (label) {
+ label += ': ';
+ }
+ const value = tooltipItem.formattedValue;
+ if (!isNullOrUndef(value)) {
+ label += value;
+ }
+ return label;
+ },
+ labelColor(tooltipItem) {
+ const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
+ const options = meta.controller.getStyle(tooltipItem.dataIndex);
+ return {
+ borderColor: options.borderColor,
+ backgroundColor: options.backgroundColor,
+ borderWidth: options.borderWidth,
+ borderDash: options.borderDash,
+ borderDashOffset: options.borderDashOffset,
+ borderRadius: 0,
+ };
+ },
+ labelTextColor() {
+ return this.options.bodyColor;
+ },
+ labelPointStyle(tooltipItem) {
+ const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);
+ const options = meta.controller.getStyle(tooltipItem.dataIndex);
+ return {
+ pointStyle: options.pointStyle,
+ rotation: options.rotation,
+ };
+ },
+ afterLabel: noop,
+ afterBody: noop,
+ beforeFooter: noop,
+ footer: noop,
+ afterFooter: noop
+ }
+ },
+ defaultRoutes: {
+ bodyFont: 'font',
+ footerFont: 'font',
+ titleFont: 'font'
+ },
+ descriptors: {
+ _scriptable: (name) => name !== 'filter' && name !== 'itemSort' && name !== 'external',
+ _indexable: false,
+ callbacks: {
+ _scriptable: false,
+ _indexable: false,
+ },
+ animation: {
+ _fallback: false
+ },
+ animations: {
+ _fallback: 'animation'
+ }
+ },
+ additionalOptionScopes: ['interaction']
+};
+
+var plugins = /*#__PURE__*/Object.freeze({
+__proto__: null,
+Decimation: plugin_decimation,
+Filler: plugin_filler,
+Legend: plugin_legend,
+SubTitle: plugin_subtitle,
+Title: plugin_title,
+Tooltip: plugin_tooltip
+});
+
+const addIfString = (labels, raw, index, addedLabels) => {
+ if (typeof raw === 'string') {
+ index = labels.push(raw) - 1;
+ addedLabels.unshift({index, label: raw});
+ } else if (isNaN(raw)) {
+ index = null;
+ }
+ return index;
+};
+function findOrAddLabel(labels, raw, index, addedLabels) {
+ const first = labels.indexOf(raw);
+ if (first === -1) {
+ return addIfString(labels, raw, index, addedLabels);
+ }
+ const last = labels.lastIndexOf(raw);
+ return first !== last ? index : first;
+}
+const validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max);
+class CategoryScale extends Scale {
+ constructor(cfg) {
+ super(cfg);
+ this._startValue = undefined;
+ this._valueRange = 0;
+ this._addedLabels = [];
+ }
+ init(scaleOptions) {
+ const added = this._addedLabels;
+ if (added.length) {
+ const labels = this.getLabels();
+ for (const {index, label} of added) {
+ if (labels[index] === label) {
+ labels.splice(index, 1);
+ }
+ }
+ this._addedLabels = [];
+ }
+ super.init(scaleOptions);
+ }
+ parse(raw, index) {
+ if (isNullOrUndef(raw)) {
+ return null;
+ }
+ const labels = this.getLabels();
+ index = isFinite(index) && labels[index] === raw ? index
+ : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);
+ return validIndex(index, labels.length - 1);
+ }
+ determineDataLimits() {
+ const {minDefined, maxDefined} = this.getUserBounds();
+ let {min, max} = this.getMinMax(true);
+ if (this.options.bounds === 'ticks') {
+ if (!minDefined) {
+ min = 0;
+ }
+ if (!maxDefined) {
+ max = this.getLabels().length - 1;
+ }
+ }
+ this.min = min;
+ this.max = max;
+ }
+ buildTicks() {
+ const min = this.min;
+ const max = this.max;
+ const offset = this.options.offset;
+ const ticks = [];
+ let labels = this.getLabels();
+ labels = (min === 0 && max === labels.length - 1) ? labels : labels.slice(min, max + 1);
+ this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1);
+ this._startValue = this.min - (offset ? 0.5 : 0);
+ for (let value = min; value <= max; value++) {
+ ticks.push({value});
+ }
+ return ticks;
+ }
+ getLabelForValue(value) {
+ const labels = this.getLabels();
+ if (value >= 0 && value < labels.length) {
+ return labels[value];
+ }
+ return value;
+ }
+ configure() {
+ super.configure();
+ if (!this.isHorizontal()) {
+ this._reversePixels = !this._reversePixels;
+ }
+ }
+ getPixelForValue(value) {
+ if (typeof value !== 'number') {
+ value = this.parse(value);
+ }
+ return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
+ }
+ getPixelForTick(index) {
+ const ticks = this.ticks;
+ if (index < 0 || index > ticks.length - 1) {
+ return null;
+ }
+ return this.getPixelForValue(ticks[index].value);
+ }
+ getValueForPixel(pixel) {
+ return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange);
+ }
+ getBasePixel() {
+ return this.bottom;
+ }
+}
+CategoryScale.id = 'category';
+CategoryScale.defaults = {
+ ticks: {
+ callback: CategoryScale.prototype.getLabelForValue
+ }
+};
+
+function generateTicks$1(generationOptions, dataRange) {
+ const ticks = [];
+ const MIN_SPACING = 1e-14;
+ const {bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds} = generationOptions;
+ const unit = step || 1;
+ const maxSpaces = maxTicks - 1;
+ const {min: rmin, max: rmax} = dataRange;
+ const minDefined = !isNullOrUndef(min);
+ const maxDefined = !isNullOrUndef(max);
+ const countDefined = !isNullOrUndef(count);
+ const minSpacing = (rmax - rmin) / (maxDigits + 1);
+ let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;
+ let factor, niceMin, niceMax, numSpaces;
+ if (spacing < MIN_SPACING && !minDefined && !maxDefined) {
+ return [{value: rmin}, {value: rmax}];
+ }
+ numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);
+ if (numSpaces > maxSpaces) {
+ spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;
+ }
+ if (!isNullOrUndef(precision)) {
+ factor = Math.pow(10, precision);
+ spacing = Math.ceil(spacing * factor) / factor;
+ }
+ if (bounds === 'ticks') {
+ niceMin = Math.floor(rmin / spacing) * spacing;
+ niceMax = Math.ceil(rmax / spacing) * spacing;
+ } else {
+ niceMin = rmin;
+ niceMax = rmax;
+ }
+ if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1000)) {
+ numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));
+ spacing = (max - min) / numSpaces;
+ niceMin = min;
+ niceMax = max;
+ } else if (countDefined) {
+ niceMin = minDefined ? min : niceMin;
+ niceMax = maxDefined ? max : niceMax;
+ numSpaces = count - 1;
+ spacing = (niceMax - niceMin) / numSpaces;
+ } else {
+ numSpaces = (niceMax - niceMin) / spacing;
+ if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {
+ numSpaces = Math.round(numSpaces);
+ } else {
+ numSpaces = Math.ceil(numSpaces);
+ }
+ }
+ const decimalPlaces = Math.max(
+ _decimalPlaces(spacing),
+ _decimalPlaces(niceMin)
+ );
+ factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);
+ niceMin = Math.round(niceMin * factor) / factor;
+ niceMax = Math.round(niceMax * factor) / factor;
+ let j = 0;
+ if (minDefined) {
+ if (includeBounds && niceMin !== min) {
+ ticks.push({value: min});
+ if (niceMin < min) {
+ j++;
+ }
+ if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {
+ j++;
+ }
+ } else if (niceMin < min) {
+ j++;
+ }
+ }
+ for (; j < numSpaces; ++j) {
+ ticks.push({value: Math.round((niceMin + j * spacing) * factor) / factor});
+ }
+ if (maxDefined && includeBounds && niceMax !== max) {
+ if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {
+ ticks[ticks.length - 1].value = max;
+ } else {
+ ticks.push({value: max});
+ }
+ } else if (!maxDefined || niceMax === max) {
+ ticks.push({value: niceMax});
+ }
+ return ticks;
+}
+function relativeLabelSize(value, minSpacing, {horizontal, minRotation}) {
+ const rad = toRadians(minRotation);
+ const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 0.001;
+ const length = 0.75 * minSpacing * ('' + value).length;
+ return Math.min(minSpacing / ratio, length);
+}
+class LinearScaleBase extends Scale {
+ constructor(cfg) {
+ super(cfg);
+ this.start = undefined;
+ this.end = undefined;
+ this._startValue = undefined;
+ this._endValue = undefined;
+ this._valueRange = 0;
+ }
+ parse(raw, index) {
+ if (isNullOrUndef(raw)) {
+ return null;
+ }
+ if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) {
+ return null;
+ }
+ return +raw;
+ }
+ handleTickRangeOptions() {
+ const {beginAtZero} = this.options;
+ const {minDefined, maxDefined} = this.getUserBounds();
+ let {min, max} = this;
+ const setMin = v => (min = minDefined ? min : v);
+ const setMax = v => (max = maxDefined ? max : v);
+ if (beginAtZero) {
+ const minSign = sign(min);
+ const maxSign = sign(max);
+ if (minSign < 0 && maxSign < 0) {
+ setMax(0);
+ } else if (minSign > 0 && maxSign > 0) {
+ setMin(0);
+ }
+ }
+ if (min === max) {
+ let offset = 1;
+ if (max >= Number.MAX_SAFE_INTEGER || min <= Number.MIN_SAFE_INTEGER) {
+ offset = Math.abs(max * 0.05);
+ }
+ setMax(max + offset);
+ if (!beginAtZero) {
+ setMin(min - offset);
+ }
+ }
+ this.min = min;
+ this.max = max;
+ }
+ getTickLimit() {
+ const tickOpts = this.options.ticks;
+ let {maxTicksLimit, stepSize} = tickOpts;
+ let maxTicks;
+ if (stepSize) {
+ maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;
+ if (maxTicks > 1000) {
+ console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);
+ maxTicks = 1000;
+ }
+ } else {
+ maxTicks = this.computeTickLimit();
+ maxTicksLimit = maxTicksLimit || 11;
+ }
+ if (maxTicksLimit) {
+ maxTicks = Math.min(maxTicksLimit, maxTicks);
+ }
+ return maxTicks;
+ }
+ computeTickLimit() {
+ return Number.POSITIVE_INFINITY;
+ }
+ buildTicks() {
+ const opts = this.options;
+ const tickOpts = opts.ticks;
+ let maxTicks = this.getTickLimit();
+ maxTicks = Math.max(2, maxTicks);
+ const numericGeneratorOptions = {
+ maxTicks,
+ bounds: opts.bounds,
+ min: opts.min,
+ max: opts.max,
+ precision: tickOpts.precision,
+ step: tickOpts.stepSize,
+ count: tickOpts.count,
+ maxDigits: this._maxDigits(),
+ horizontal: this.isHorizontal(),
+ minRotation: tickOpts.minRotation || 0,
+ includeBounds: tickOpts.includeBounds !== false
+ };
+ const dataRange = this._range || this;
+ const ticks = generateTicks$1(numericGeneratorOptions, dataRange);
+ if (opts.bounds === 'ticks') {
+ _setMinAndMaxByKey(ticks, this, 'value');
+ }
+ if (opts.reverse) {
+ ticks.reverse();
+ this.start = this.max;
+ this.end = this.min;
+ } else {
+ this.start = this.min;
+ this.end = this.max;
+ }
+ return ticks;
+ }
+ configure() {
+ const ticks = this.ticks;
+ let start = this.min;
+ let end = this.max;
+ super.configure();
+ if (this.options.offset && ticks.length) {
+ const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;
+ start -= offset;
+ end += offset;
+ }
+ this._startValue = start;
+ this._endValue = end;
+ this._valueRange = end - start;
+ }
+ getLabelForValue(value) {
+ return formatNumber(value, this.chart.options.locale, this.options.ticks.format);
+ }
+}
+
+class LinearScale extends LinearScaleBase {
+ determineDataLimits() {
+ const {min, max} = this.getMinMax(true);
+ this.min = isNumberFinite(min) ? min : 0;
+ this.max = isNumberFinite(max) ? max : 1;
+ this.handleTickRangeOptions();
+ }
+ computeTickLimit() {
+ const horizontal = this.isHorizontal();
+ const length = horizontal ? this.width : this.height;
+ const minRotation = toRadians(this.options.ticks.minRotation);
+ const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 0.001;
+ const tickFont = this._resolveTickFontOptions(0);
+ return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));
+ }
+ getPixelForValue(value) {
+ return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);
+ }
+ getValueForPixel(pixel) {
+ return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;
+ }
+}
+LinearScale.id = 'linear';
+LinearScale.defaults = {
+ ticks: {
+ callback: Ticks.formatters.numeric
+ }
+};
+
+function isMajor(tickVal) {
+ const remain = tickVal / (Math.pow(10, Math.floor(log10(tickVal))));
+ return remain === 1;
+}
+function generateTicks(generationOptions, dataRange) {
+ const endExp = Math.floor(log10(dataRange.max));
+ const endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp));
+ const ticks = [];
+ let tickVal = finiteOrDefault(generationOptions.min, Math.pow(10, Math.floor(log10(dataRange.min))));
+ let exp = Math.floor(log10(tickVal));
+ let significand = Math.floor(tickVal / Math.pow(10, exp));
+ let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;
+ do {
+ ticks.push({value: tickVal, major: isMajor(tickVal)});
+ ++significand;
+ if (significand === 10) {
+ significand = 1;
+ ++exp;
+ precision = exp >= 0 ? 1 : precision;
+ }
+ tickVal = Math.round(significand * Math.pow(10, exp) * precision) / precision;
+ } while (exp < endExp || (exp === endExp && significand < endSignificand));
+ const lastTick = finiteOrDefault(generationOptions.max, tickVal);
+ ticks.push({value: lastTick, major: isMajor(tickVal)});
+ return ticks;
+}
+class LogarithmicScale extends Scale {
+ constructor(cfg) {
+ super(cfg);
+ this.start = undefined;
+ this.end = undefined;
+ this._startValue = undefined;
+ this._valueRange = 0;
+ }
+ parse(raw, index) {
+ const value = LinearScaleBase.prototype.parse.apply(this, [raw, index]);
+ if (value === 0) {
+ this._zero = true;
+ return undefined;
+ }
+ return isNumberFinite(value) && value > 0 ? value : null;
+ }
+ determineDataLimits() {
+ const {min, max} = this.getMinMax(true);
+ this.min = isNumberFinite(min) ? Math.max(0, min) : null;
+ this.max = isNumberFinite(max) ? Math.max(0, max) : null;
+ if (this.options.beginAtZero) {
+ this._zero = true;
+ }
+ this.handleTickRangeOptions();
+ }
+ handleTickRangeOptions() {
+ const {minDefined, maxDefined} = this.getUserBounds();
+ let min = this.min;
+ let max = this.max;
+ const setMin = v => (min = minDefined ? min : v);
+ const setMax = v => (max = maxDefined ? max : v);
+ const exp = (v, m) => Math.pow(10, Math.floor(log10(v)) + m);
+ if (min === max) {
+ if (min <= 0) {
+ setMin(1);
+ setMax(10);
+ } else {
+ setMin(exp(min, -1));
+ setMax(exp(max, +1));
+ }
+ }
+ if (min <= 0) {
+ setMin(exp(max, -1));
+ }
+ if (max <= 0) {
+ setMax(exp(min, +1));
+ }
+ if (this._zero && this.min !== this._suggestedMin && min === exp(this.min, 0)) {
+ setMin(exp(min, -1));
+ }
+ this.min = min;
+ this.max = max;
+ }
+ buildTicks() {
+ const opts = this.options;
+ const generationOptions = {
+ min: this._userMin,
+ max: this._userMax
+ };
+ const ticks = generateTicks(generationOptions, this);
+ if (opts.bounds === 'ticks') {
+ _setMinAndMaxByKey(ticks, this, 'value');
+ }
+ if (opts.reverse) {
+ ticks.reverse();
+ this.start = this.max;
+ this.end = this.min;
+ } else {
+ this.start = this.min;
+ this.end = this.max;
+ }
+ return ticks;
+ }
+ getLabelForValue(value) {
+ return value === undefined
+ ? '0'
+ : formatNumber(value, this.chart.options.locale, this.options.ticks.format);
+ }
+ configure() {
+ const start = this.min;
+ super.configure();
+ this._startValue = log10(start);
+ this._valueRange = log10(this.max) - log10(start);
+ }
+ getPixelForValue(value) {
+ if (value === undefined || value === 0) {
+ value = this.min;
+ }
+ if (value === null || isNaN(value)) {
+ return NaN;
+ }
+ return this.getPixelForDecimal(value === this.min
+ ? 0
+ : (log10(value) - this._startValue) / this._valueRange);
+ }
+ getValueForPixel(pixel) {
+ const decimal = this.getDecimalForPixel(pixel);
+ return Math.pow(10, this._startValue + decimal * this._valueRange);
+ }
+}
+LogarithmicScale.id = 'logarithmic';
+LogarithmicScale.defaults = {
+ ticks: {
+ callback: Ticks.formatters.logarithmic,
+ major: {
+ enabled: true
+ }
+ }
+};
+
+function getTickBackdropHeight(opts) {
+ const tickOpts = opts.ticks;
+ if (tickOpts.display && opts.display) {
+ const padding = toPadding(tickOpts.backdropPadding);
+ return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + padding.height;
+ }
+ return 0;
+}
+function measureLabelSize(ctx, font, label) {
+ label = isArray(label) ? label : [label];
+ return {
+ w: _longestText(ctx, font.string, label),
+ h: label.length * font.lineHeight
+ };
+}
+function determineLimits(angle, pos, size, min, max) {
+ if (angle === min || angle === max) {
+ return {
+ start: pos - (size / 2),
+ end: pos + (size / 2)
+ };
+ } else if (angle < min || angle > max) {
+ return {
+ start: pos - size,
+ end: pos
+ };
+ }
+ return {
+ start: pos,
+ end: pos + size
+ };
+}
+function fitWithPointLabels(scale) {
+ const orig = {
+ l: scale.left + scale._padding.left,
+ r: scale.right - scale._padding.right,
+ t: scale.top + scale._padding.top,
+ b: scale.bottom - scale._padding.bottom
+ };
+ const limits = Object.assign({}, orig);
+ const labelSizes = [];
+ const padding = [];
+ const valueCount = scale._pointLabels.length;
+ const pointLabelOpts = scale.options.pointLabels;
+ const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;
+ for (let i = 0; i < valueCount; i++) {
+ const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i));
+ padding[i] = opts.padding;
+ const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle);
+ const plFont = toFont(opts.font);
+ const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]);
+ labelSizes[i] = textSize;
+ const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle);
+ const angle = Math.round(toDegrees(angleRadians));
+ const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);
+ const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);
+ updateLimits(limits, orig, angleRadians, hLimits, vLimits);
+ }
+ scale.setCenterPoint(
+ orig.l - limits.l,
+ limits.r - orig.r,
+ orig.t - limits.t,
+ limits.b - orig.b
+ );
+ scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);
+}
+function updateLimits(limits, orig, angle, hLimits, vLimits) {
+ const sin = Math.abs(Math.sin(angle));
+ const cos = Math.abs(Math.cos(angle));
+ let x = 0;
+ let y = 0;
+ if (hLimits.start < orig.l) {
+ x = (orig.l - hLimits.start) / sin;
+ limits.l = Math.min(limits.l, orig.l - x);
+ } else if (hLimits.end > orig.r) {
+ x = (hLimits.end - orig.r) / sin;
+ limits.r = Math.max(limits.r, orig.r + x);
+ }
+ if (vLimits.start < orig.t) {
+ y = (orig.t - vLimits.start) / cos;
+ limits.t = Math.min(limits.t, orig.t - y);
+ } else if (vLimits.end > orig.b) {
+ y = (vLimits.end - orig.b) / cos;
+ limits.b = Math.max(limits.b, orig.b + y);
+ }
+}
+function buildPointLabelItems(scale, labelSizes, padding) {
+ const items = [];
+ const valueCount = scale._pointLabels.length;
+ const opts = scale.options;
+ const extra = getTickBackdropHeight(opts) / 2;
+ const outerDistance = scale.drawingArea;
+ const additionalAngle = opts.pointLabels.centerPointLabels ? PI / valueCount : 0;
+ for (let i = 0; i < valueCount; i++) {
+ const pointLabelPosition = scale.getPointPosition(i, outerDistance + extra + padding[i], additionalAngle);
+ const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));
+ const size = labelSizes[i];
+ const y = yForAngle(pointLabelPosition.y, size.h, angle);
+ const textAlign = getTextAlignForAngle(angle);
+ const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign);
+ items.push({
+ x: pointLabelPosition.x,
+ y,
+ textAlign,
+ left,
+ top: y,
+ right: left + size.w,
+ bottom: y + size.h
+ });
+ }
+ return items;
+}
+function getTextAlignForAngle(angle) {
+ if (angle === 0 || angle === 180) {
+ return 'center';
+ } else if (angle < 180) {
+ return 'left';
+ }
+ return 'right';
+}
+function leftForTextAlign(x, w, align) {
+ if (align === 'right') {
+ x -= w;
+ } else if (align === 'center') {
+ x -= (w / 2);
+ }
+ return x;
+}
+function yForAngle(y, h, angle) {
+ if (angle === 90 || angle === 270) {
+ y -= (h / 2);
+ } else if (angle > 270 || angle < 90) {
+ y -= h;
+ }
+ return y;
+}
+function drawPointLabels(scale, labelCount) {
+ const {ctx, options: {pointLabels}} = scale;
+ for (let i = labelCount - 1; i >= 0; i--) {
+ const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i));
+ const plFont = toFont(optsAtIndex.font);
+ const {x, y, textAlign, left, top, right, bottom} = scale._pointLabelItems[i];
+ const {backdropColor} = optsAtIndex;
+ if (!isNullOrUndef(backdropColor)) {
+ const padding = toPadding(optsAtIndex.backdropPadding);
+ ctx.fillStyle = backdropColor;
+ ctx.fillRect(left - padding.left, top - padding.top, right - left + padding.width, bottom - top + padding.height);
+ }
+ renderText(
+ ctx,
+ scale._pointLabels[i],
+ x,
+ y + (plFont.lineHeight / 2),
+ plFont,
+ {
+ color: optsAtIndex.color,
+ textAlign: textAlign,
+ textBaseline: 'middle'
+ }
+ );
+ }
+}
+function pathRadiusLine(scale, radius, circular, labelCount) {
+ const {ctx} = scale;
+ if (circular) {
+ ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU);
+ } else {
+ let pointPosition = scale.getPointPosition(0, radius);
+ ctx.moveTo(pointPosition.x, pointPosition.y);
+ for (let i = 1; i < labelCount; i++) {
+ pointPosition = scale.getPointPosition(i, radius);
+ ctx.lineTo(pointPosition.x, pointPosition.y);
+ }
+ }
+}
+function drawRadiusLine(scale, gridLineOpts, radius, labelCount) {
+ const ctx = scale.ctx;
+ const circular = gridLineOpts.circular;
+ const {color, lineWidth} = gridLineOpts;
+ if ((!circular && !labelCount) || !color || !lineWidth || radius < 0) {
+ return;
+ }
+ ctx.save();
+ ctx.strokeStyle = color;
+ ctx.lineWidth = lineWidth;
+ ctx.setLineDash(gridLineOpts.borderDash);
+ ctx.lineDashOffset = gridLineOpts.borderDashOffset;
+ ctx.beginPath();
+ pathRadiusLine(scale, radius, circular, labelCount);
+ ctx.closePath();
+ ctx.stroke();
+ ctx.restore();
+}
+function createPointLabelContext(parent, index, label) {
+ return createContext(parent, {
+ label,
+ index,
+ type: 'pointLabel'
+ });
+}
+class RadialLinearScale extends LinearScaleBase {
+ constructor(cfg) {
+ super(cfg);
+ this.xCenter = undefined;
+ this.yCenter = undefined;
+ this.drawingArea = undefined;
+ this._pointLabels = [];
+ this._pointLabelItems = [];
+ }
+ setDimensions() {
+ const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);
+ const w = this.width = this.maxWidth - padding.width;
+ const h = this.height = this.maxHeight - padding.height;
+ this.xCenter = Math.floor(this.left + w / 2 + padding.left);
+ this.yCenter = Math.floor(this.top + h / 2 + padding.top);
+ this.drawingArea = Math.floor(Math.min(w, h) / 2);
+ }
+ determineDataLimits() {
+ const {min, max} = this.getMinMax(false);
+ this.min = isNumberFinite(min) && !isNaN(min) ? min : 0;
+ this.max = isNumberFinite(max) && !isNaN(max) ? max : 0;
+ this.handleTickRangeOptions();
+ }
+ computeTickLimit() {
+ return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));
+ }
+ generateTickLabels(ticks) {
+ LinearScaleBase.prototype.generateTickLabels.call(this, ticks);
+ this._pointLabels = this.getLabels()
+ .map((value, index) => {
+ const label = callback(this.options.pointLabels.callback, [value, index], this);
+ return label || label === 0 ? label : '';
+ })
+ .filter((v, i) => this.chart.getDataVisibility(i));
+ }
+ fit() {
+ const opts = this.options;
+ if (opts.display && opts.pointLabels.display) {
+ fitWithPointLabels(this);
+ } else {
+ this.setCenterPoint(0, 0, 0, 0);
+ }
+ }
+ setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {
+ this.xCenter += Math.floor((leftMovement - rightMovement) / 2);
+ this.yCenter += Math.floor((topMovement - bottomMovement) / 2);
+ this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));
+ }
+ getIndexAngle(index) {
+ const angleMultiplier = TAU / (this._pointLabels.length || 1);
+ const startAngle = this.options.startAngle || 0;
+ return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));
+ }
+ getDistanceFromCenterForValue(value) {
+ if (isNullOrUndef(value)) {
+ return NaN;
+ }
+ const scalingFactor = this.drawingArea / (this.max - this.min);
+ if (this.options.reverse) {
+ return (this.max - value) * scalingFactor;
+ }
+ return (value - this.min) * scalingFactor;
+ }
+ getValueForDistanceFromCenter(distance) {
+ if (isNullOrUndef(distance)) {
+ return NaN;
+ }
+ const scaledDistance = distance / (this.drawingArea / (this.max - this.min));
+ return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance;
+ }
+ getPointLabelContext(index) {
+ const pointLabels = this._pointLabels || [];
+ if (index >= 0 && index < pointLabels.length) {
+ const pointLabel = pointLabels[index];
+ return createPointLabelContext(this.getContext(), index, pointLabel);
+ }
+ }
+ getPointPosition(index, distanceFromCenter, additionalAngle = 0) {
+ const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;
+ return {
+ x: Math.cos(angle) * distanceFromCenter + this.xCenter,
+ y: Math.sin(angle) * distanceFromCenter + this.yCenter,
+ angle
+ };
+ }
+ getPointPositionForValue(index, value) {
+ return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));
+ }
+ getBasePosition(index) {
+ return this.getPointPositionForValue(index || 0, this.getBaseValue());
+ }
+ getPointLabelPosition(index) {
+ const {left, top, right, bottom} = this._pointLabelItems[index];
+ return {
+ left,
+ top,
+ right,
+ bottom,
+ };
+ }
+ drawBackground() {
+ const {backgroundColor, grid: {circular}} = this.options;
+ if (backgroundColor) {
+ const ctx = this.ctx;
+ ctx.save();
+ ctx.beginPath();
+ pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);
+ ctx.closePath();
+ ctx.fillStyle = backgroundColor;
+ ctx.fill();
+ ctx.restore();
+ }
+ }
+ drawGrid() {
+ const ctx = this.ctx;
+ const opts = this.options;
+ const {angleLines, grid} = opts;
+ const labelCount = this._pointLabels.length;
+ let i, offset, position;
+ if (opts.pointLabels.display) {
+ drawPointLabels(this, labelCount);
+ }
+ if (grid.display) {
+ this.ticks.forEach((tick, index) => {
+ if (index !== 0) {
+ offset = this.getDistanceFromCenterForValue(tick.value);
+ const optsAtIndex = grid.setContext(this.getContext(index - 1));
+ drawRadiusLine(this, optsAtIndex, offset, labelCount);
+ }
+ });
+ }
+ if (angleLines.display) {
+ ctx.save();
+ for (i = labelCount - 1; i >= 0; i--) {
+ const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i));
+ const {color, lineWidth} = optsAtIndex;
+ if (!lineWidth || !color) {
+ continue;
+ }
+ ctx.lineWidth = lineWidth;
+ ctx.strokeStyle = color;
+ ctx.setLineDash(optsAtIndex.borderDash);
+ ctx.lineDashOffset = optsAtIndex.borderDashOffset;
+ offset = this.getDistanceFromCenterForValue(opts.ticks.reverse ? this.min : this.max);
+ position = this.getPointPosition(i, offset);
+ ctx.beginPath();
+ ctx.moveTo(this.xCenter, this.yCenter);
+ ctx.lineTo(position.x, position.y);
+ ctx.stroke();
+ }
+ ctx.restore();
+ }
+ }
+ drawBorder() {}
+ drawLabels() {
+ const ctx = this.ctx;
+ const opts = this.options;
+ const tickOpts = opts.ticks;
+ if (!tickOpts.display) {
+ return;
+ }
+ const startAngle = this.getIndexAngle(0);
+ let offset, width;
+ ctx.save();
+ ctx.translate(this.xCenter, this.yCenter);
+ ctx.rotate(startAngle);
+ ctx.textAlign = 'center';
+ ctx.textBaseline = 'middle';
+ this.ticks.forEach((tick, index) => {
+ if (index === 0 && !opts.reverse) {
+ return;
+ }
+ const optsAtIndex = tickOpts.setContext(this.getContext(index));
+ const tickFont = toFont(optsAtIndex.font);
+ offset = this.getDistanceFromCenterForValue(this.ticks[index].value);
+ if (optsAtIndex.showLabelBackdrop) {
+ ctx.font = tickFont.string;
+ width = ctx.measureText(tick.label).width;
+ ctx.fillStyle = optsAtIndex.backdropColor;
+ const padding = toPadding(optsAtIndex.backdropPadding);
+ ctx.fillRect(
+ -width / 2 - padding.left,
+ -offset - tickFont.size / 2 - padding.top,
+ width + padding.width,
+ tickFont.size + padding.height
+ );
+ }
+ renderText(ctx, tick.label, 0, -offset, tickFont, {
+ color: optsAtIndex.color,
+ });
+ });
+ ctx.restore();
+ }
+ drawTitle() {}
+}
+RadialLinearScale.id = 'radialLinear';
+RadialLinearScale.defaults = {
+ display: true,
+ animate: true,
+ position: 'chartArea',
+ angleLines: {
+ display: true,
+ lineWidth: 1,
+ borderDash: [],
+ borderDashOffset: 0.0
+ },
+ grid: {
+ circular: false
+ },
+ startAngle: 0,
+ ticks: {
+ showLabelBackdrop: true,
+ callback: Ticks.formatters.numeric
+ },
+ pointLabels: {
+ backdropColor: undefined,
+ backdropPadding: 2,
+ display: true,
+ font: {
+ size: 10
+ },
+ callback(label) {
+ return label;
+ },
+ padding: 5,
+ centerPointLabels: false
+ }
+};
+RadialLinearScale.defaultRoutes = {
+ 'angleLines.color': 'borderColor',
+ 'pointLabels.color': 'color',
+ 'ticks.color': 'color'
+};
+RadialLinearScale.descriptors = {
+ angleLines: {
+ _fallback: 'grid'
+ }
+};
+
+const INTERVALS = {
+ millisecond: {common: true, size: 1, steps: 1000},
+ second: {common: true, size: 1000, steps: 60},
+ minute: {common: true, size: 60000, steps: 60},
+ hour: {common: true, size: 3600000, steps: 24},
+ day: {common: true, size: 86400000, steps: 30},
+ week: {common: false, size: 604800000, steps: 4},
+ month: {common: true, size: 2.628e9, steps: 12},
+ quarter: {common: false, size: 7.884e9, steps: 4},
+ year: {common: true, size: 3.154e10}
+};
+const UNITS = (Object.keys(INTERVALS));
+function sorter(a, b) {
+ return a - b;
+}
+function parse(scale, input) {
+ if (isNullOrUndef(input)) {
+ return null;
+ }
+ const adapter = scale._adapter;
+ const {parser, round, isoWeekday} = scale._parseOpts;
+ let value = input;
+ if (typeof parser === 'function') {
+ value = parser(value);
+ }
+ if (!isNumberFinite(value)) {
+ value = typeof parser === 'string'
+ ? adapter.parse(value, parser)
+ : adapter.parse(value);
+ }
+ if (value === null) {
+ return null;
+ }
+ if (round) {
+ value = round === 'week' && (isNumber(isoWeekday) || isoWeekday === true)
+ ? adapter.startOf(value, 'isoWeek', isoWeekday)
+ : adapter.startOf(value, round);
+ }
+ return +value;
+}
+function determineUnitForAutoTicks(minUnit, min, max, capacity) {
+ const ilen = UNITS.length;
+ for (let i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) {
+ const interval = INTERVALS[UNITS[i]];
+ const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER;
+ if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) {
+ return UNITS[i];
+ }
+ }
+ return UNITS[ilen - 1];
+}
+function determineUnitForFormatting(scale, numTicks, minUnit, min, max) {
+ for (let i = UNITS.length - 1; i >= UNITS.indexOf(minUnit); i--) {
+ const unit = UNITS[i];
+ if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) {
+ return unit;
+ }
+ }
+ return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0];
+}
+function determineMajorUnit(unit) {
+ for (let i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) {
+ if (INTERVALS[UNITS[i]].common) {
+ return UNITS[i];
+ }
+ }
+}
+function addTick(ticks, time, timestamps) {
+ if (!timestamps) {
+ ticks[time] = true;
+ } else if (timestamps.length) {
+ const {lo, hi} = _lookup(timestamps, time);
+ const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi];
+ ticks[timestamp] = true;
+ }
+}
+function setMajorTicks(scale, ticks, map, majorUnit) {
+ const adapter = scale._adapter;
+ const first = +adapter.startOf(ticks[0].value, majorUnit);
+ const last = ticks[ticks.length - 1].value;
+ let major, index;
+ for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) {
+ index = map[major];
+ if (index >= 0) {
+ ticks[index].major = true;
+ }
+ }
+ return ticks;
+}
+function ticksFromTimestamps(scale, values, majorUnit) {
+ const ticks = [];
+ const map = {};
+ const ilen = values.length;
+ let i, value;
+ for (i = 0; i < ilen; ++i) {
+ value = values[i];
+ map[value] = i;
+ ticks.push({
+ value,
+ major: false
+ });
+ }
+ return (ilen === 0 || !majorUnit) ? ticks : setMajorTicks(scale, ticks, map, majorUnit);
+}
+class TimeScale extends Scale {
+ constructor(props) {
+ super(props);
+ this._cache = {
+ data: [],
+ labels: [],
+ all: []
+ };
+ this._unit = 'day';
+ this._majorUnit = undefined;
+ this._offsets = {};
+ this._normalized = false;
+ this._parseOpts = undefined;
+ }
+ init(scaleOpts, opts) {
+ const time = scaleOpts.time || (scaleOpts.time = {});
+ const adapter = this._adapter = new _adapters._date(scaleOpts.adapters.date);
+ mergeIf(time.displayFormats, adapter.formats());
+ this._parseOpts = {
+ parser: time.parser,
+ round: time.round,
+ isoWeekday: time.isoWeekday
+ };
+ super.init(scaleOpts);
+ this._normalized = opts.normalized;
+ }
+ parse(raw, index) {
+ if (raw === undefined) {
+ return null;
+ }
+ return parse(this, raw);
+ }
+ beforeLayout() {
+ super.beforeLayout();
+ this._cache = {
+ data: [],
+ labels: [],
+ all: []
+ };
+ }
+ determineDataLimits() {
+ const options = this.options;
+ const adapter = this._adapter;
+ const unit = options.time.unit || 'day';
+ let {min, max, minDefined, maxDefined} = this.getUserBounds();
+ function _applyBounds(bounds) {
+ if (!minDefined && !isNaN(bounds.min)) {
+ min = Math.min(min, bounds.min);
+ }
+ if (!maxDefined && !isNaN(bounds.max)) {
+ max = Math.max(max, bounds.max);
+ }
+ }
+ if (!minDefined || !maxDefined) {
+ _applyBounds(this._getLabelBounds());
+ if (options.bounds !== 'ticks' || options.ticks.source !== 'labels') {
+ _applyBounds(this.getMinMax(false));
+ }
+ }
+ min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit);
+ max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1;
+ this.min = Math.min(min, max - 1);
+ this.max = Math.max(min + 1, max);
+ }
+ _getLabelBounds() {
+ const arr = this.getLabelTimestamps();
+ let min = Number.POSITIVE_INFINITY;
+ let max = Number.NEGATIVE_INFINITY;
+ if (arr.length) {
+ min = arr[0];
+ max = arr[arr.length - 1];
+ }
+ return {min, max};
+ }
+ buildTicks() {
+ const options = this.options;
+ const timeOpts = options.time;
+ const tickOpts = options.ticks;
+ const timestamps = tickOpts.source === 'labels' ? this.getLabelTimestamps() : this._generate();
+ if (options.bounds === 'ticks' && timestamps.length) {
+ this.min = this._userMin || timestamps[0];
+ this.max = this._userMax || timestamps[timestamps.length - 1];
+ }
+ const min = this.min;
+ const max = this.max;
+ const ticks = _filterBetween(timestamps, min, max);
+ this._unit = timeOpts.unit || (tickOpts.autoSkip
+ ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min))
+ : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max));
+ this._majorUnit = !tickOpts.major.enabled || this._unit === 'year' ? undefined
+ : determineMajorUnit(this._unit);
+ this.initOffsets(timestamps);
+ if (options.reverse) {
+ ticks.reverse();
+ }
+ return ticksFromTimestamps(this, ticks, this._majorUnit);
+ }
+ initOffsets(timestamps) {
+ let start = 0;
+ let end = 0;
+ let first, last;
+ if (this.options.offset && timestamps.length) {
+ first = this.getDecimalForValue(timestamps[0]);
+ if (timestamps.length === 1) {
+ start = 1 - first;
+ } else {
+ start = (this.getDecimalForValue(timestamps[1]) - first) / 2;
+ }
+ last = this.getDecimalForValue(timestamps[timestamps.length - 1]);
+ if (timestamps.length === 1) {
+ end = last;
+ } else {
+ end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2;
+ }
+ }
+ const limit = timestamps.length < 3 ? 0.5 : 0.25;
+ start = _limitValue(start, 0, limit);
+ end = _limitValue(end, 0, limit);
+ this._offsets = {start, end, factor: 1 / (start + 1 + end)};
+ }
+ _generate() {
+ const adapter = this._adapter;
+ const min = this.min;
+ const max = this.max;
+ const options = this.options;
+ const timeOpts = options.time;
+ const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min));
+ const stepSize = valueOrDefault(timeOpts.stepSize, 1);
+ const weekday = minor === 'week' ? timeOpts.isoWeekday : false;
+ const hasWeekday = isNumber(weekday) || weekday === true;
+ const ticks = {};
+ let first = min;
+ let time, count;
+ if (hasWeekday) {
+ first = +adapter.startOf(first, 'isoWeek', weekday);
+ }
+ first = +adapter.startOf(first, hasWeekday ? 'day' : minor);
+ if (adapter.diff(max, min, minor) > 100000 * stepSize) {
+ throw new Error(min + ' and ' + max + ' are too far apart with stepSize of ' + stepSize + ' ' + minor);
+ }
+ const timestamps = options.ticks.source === 'data' && this.getDataTimestamps();
+ for (time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++) {
+ addTick(ticks, time, timestamps);
+ }
+ if (time === max || options.bounds === 'ticks' || count === 1) {
+ addTick(ticks, time, timestamps);
+ }
+ return Object.keys(ticks).sort((a, b) => a - b).map(x => +x);
+ }
+ getLabelForValue(value) {
+ const adapter = this._adapter;
+ const timeOpts = this.options.time;
+ if (timeOpts.tooltipFormat) {
+ return adapter.format(value, timeOpts.tooltipFormat);
+ }
+ return adapter.format(value, timeOpts.displayFormats.datetime);
+ }
+ _tickFormatFunction(time, index, ticks, format) {
+ const options = this.options;
+ const formats = options.time.displayFormats;
+ const unit = this._unit;
+ const majorUnit = this._majorUnit;
+ const minorFormat = unit && formats[unit];
+ const majorFormat = majorUnit && formats[majorUnit];
+ const tick = ticks[index];
+ const major = majorUnit && majorFormat && tick && tick.major;
+ const label = this._adapter.format(time, format || (major ? majorFormat : minorFormat));
+ const formatter = options.ticks.callback;
+ return formatter ? callback(formatter, [label, index, ticks], this) : label;
+ }
+ generateTickLabels(ticks) {
+ let i, ilen, tick;
+ for (i = 0, ilen = ticks.length; i < ilen; ++i) {
+ tick = ticks[i];
+ tick.label = this._tickFormatFunction(tick.value, i, ticks);
+ }
+ }
+ getDecimalForValue(value) {
+ return value === null ? NaN : (value - this.min) / (this.max - this.min);
+ }
+ getPixelForValue(value) {
+ const offsets = this._offsets;
+ const pos = this.getDecimalForValue(value);
+ return this.getPixelForDecimal((offsets.start + pos) * offsets.factor);
+ }
+ getValueForPixel(pixel) {
+ const offsets = this._offsets;
+ const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
+ return this.min + pos * (this.max - this.min);
+ }
+ _getLabelSize(label) {
+ const ticksOpts = this.options.ticks;
+ const tickLabelWidth = this.ctx.measureText(label).width;
+ const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation);
+ const cosRotation = Math.cos(angle);
+ const sinRotation = Math.sin(angle);
+ const tickFontSize = this._resolveTickFontOptions(0).size;
+ return {
+ w: (tickLabelWidth * cosRotation) + (tickFontSize * sinRotation),
+ h: (tickLabelWidth * sinRotation) + (tickFontSize * cosRotation)
+ };
+ }
+ _getLabelCapacity(exampleTime) {
+ const timeOpts = this.options.time;
+ const displayFormats = timeOpts.displayFormats;
+ const format = displayFormats[timeOpts.unit] || displayFormats.millisecond;
+ const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [exampleTime], this._majorUnit), format);
+ const size = this._getLabelSize(exampleLabel);
+ const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1;
+ return capacity > 0 ? capacity : 1;
+ }
+ getDataTimestamps() {
+ let timestamps = this._cache.data || [];
+ let i, ilen;
+ if (timestamps.length) {
+ return timestamps;
+ }
+ const metas = this.getMatchingVisibleMetas();
+ if (this._normalized && metas.length) {
+ return (this._cache.data = metas[0].controller.getAllParsedValues(this));
+ }
+ for (i = 0, ilen = metas.length; i < ilen; ++i) {
+ timestamps = timestamps.concat(metas[i].controller.getAllParsedValues(this));
+ }
+ return (this._cache.data = this.normalize(timestamps));
+ }
+ getLabelTimestamps() {
+ const timestamps = this._cache.labels || [];
+ let i, ilen;
+ if (timestamps.length) {
+ return timestamps;
+ }
+ const labels = this.getLabels();
+ for (i = 0, ilen = labels.length; i < ilen; ++i) {
+ timestamps.push(parse(this, labels[i]));
+ }
+ return (this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps));
+ }
+ normalize(values) {
+ return _arrayUnique(values.sort(sorter));
+ }
+}
+TimeScale.id = 'time';
+TimeScale.defaults = {
+ bounds: 'data',
+ adapters: {},
+ time: {
+ parser: false,
+ unit: false,
+ round: false,
+ isoWeekday: false,
+ minUnit: 'millisecond',
+ displayFormats: {}
+ },
+ ticks: {
+ source: 'auto',
+ major: {
+ enabled: false
+ }
+ }
+};
+
+function interpolate(table, val, reverse) {
+ let lo = 0;
+ let hi = table.length - 1;
+ let prevSource, nextSource, prevTarget, nextTarget;
+ if (reverse) {
+ if (val >= table[lo].pos && val <= table[hi].pos) {
+ ({lo, hi} = _lookupByKey(table, 'pos', val));
+ }
+ ({pos: prevSource, time: prevTarget} = table[lo]);
+ ({pos: nextSource, time: nextTarget} = table[hi]);
+ } else {
+ if (val >= table[lo].time && val <= table[hi].time) {
+ ({lo, hi} = _lookupByKey(table, 'time', val));
+ }
+ ({time: prevSource, pos: prevTarget} = table[lo]);
+ ({time: nextSource, pos: nextTarget} = table[hi]);
+ }
+ const span = nextSource - prevSource;
+ return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget;
+}
+class TimeSeriesScale extends TimeScale {
+ constructor(props) {
+ super(props);
+ this._table = [];
+ this._minPos = undefined;
+ this._tableRange = undefined;
+ }
+ initOffsets() {
+ const timestamps = this._getTimestampsForTable();
+ const table = this._table = this.buildLookupTable(timestamps);
+ this._minPos = interpolate(table, this.min);
+ this._tableRange = interpolate(table, this.max) - this._minPos;
+ super.initOffsets(timestamps);
+ }
+ buildLookupTable(timestamps) {
+ const {min, max} = this;
+ const items = [];
+ const table = [];
+ let i, ilen, prev, curr, next;
+ for (i = 0, ilen = timestamps.length; i < ilen; ++i) {
+ curr = timestamps[i];
+ if (curr >= min && curr <= max) {
+ items.push(curr);
+ }
+ }
+ if (items.length < 2) {
+ return [
+ {time: min, pos: 0},
+ {time: max, pos: 1}
+ ];
+ }
+ for (i = 0, ilen = items.length; i < ilen; ++i) {
+ next = items[i + 1];
+ prev = items[i - 1];
+ curr = items[i];
+ if (Math.round((next + prev) / 2) !== curr) {
+ table.push({time: curr, pos: i / (ilen - 1)});
+ }
+ }
+ return table;
+ }
+ _getTimestampsForTable() {
+ let timestamps = this._cache.all || [];
+ if (timestamps.length) {
+ return timestamps;
+ }
+ const data = this.getDataTimestamps();
+ const label = this.getLabelTimestamps();
+ if (data.length && label.length) {
+ timestamps = this.normalize(data.concat(label));
+ } else {
+ timestamps = data.length ? data : label;
+ }
+ timestamps = this._cache.all = timestamps;
+ return timestamps;
+ }
+ getDecimalForValue(value) {
+ return (interpolate(this._table, value) - this._minPos) / this._tableRange;
+ }
+ getValueForPixel(pixel) {
+ const offsets = this._offsets;
+ const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;
+ return interpolate(this._table, decimal * this._tableRange + this._minPos, true);
+ }
+}
+TimeSeriesScale.id = 'timeseries';
+TimeSeriesScale.defaults = TimeScale.defaults;
+
+var scales = /*#__PURE__*/Object.freeze({
+__proto__: null,
+CategoryScale: CategoryScale,
+LinearScale: LinearScale,
+LogarithmicScale: LogarithmicScale,
+RadialLinearScale: RadialLinearScale,
+TimeScale: TimeScale,
+TimeSeriesScale: TimeSeriesScale
+});
+
+Chart.register(controllers, scales, elements, plugins);
+Chart.helpers = {...helpers};
+Chart._adapters = _adapters;
+Chart.Animation = Animation;
+Chart.Animations = Animations;
+Chart.animator = animator;
+Chart.controllers = registry.controllers.items;
+Chart.DatasetController = DatasetController;
+Chart.Element = Element;
+Chart.elements = elements;
+Chart.Interaction = Interaction;
+Chart.layouts = layouts;
+Chart.platforms = platforms;
+Chart.Scale = Scale;
+Chart.Ticks = Ticks;
+Object.assign(Chart, controllers, scales, elements, plugins, platforms);
+Chart.Chart = Chart;
+if (typeof window !== 'undefined') {
+ window.Chart = Chart;
+}
+
+return Chart;
+
+}));