You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9874 lines
364 KiB
9874 lines
364 KiB
1 year ago
|
/*!
|
||
|
* Chart.js
|
||
|
* http://chartjs.org/
|
||
|
* Version: 2.7.2
|
||
|
*
|
||
|
* Copyright 2018 Chart.js Contributors
|
||
|
* Released under the MIT license
|
||
|
* https://github.com/chartjs/Chart.js/blob/master/LICENSE.md
|
||
|
*/
|
||
|
!(function (t) {
|
||
|
if ("object" == typeof exports && "undefined" != typeof module)
|
||
|
module.exports = t();
|
||
|
else if ("function" == typeof define && define.amd) define([], t);
|
||
|
else {
|
||
|
("undefined" != typeof window
|
||
|
? window
|
||
|
: "undefined" != typeof global
|
||
|
? global
|
||
|
: "undefined" != typeof self
|
||
|
? self
|
||
|
: this
|
||
|
).Chart = t();
|
||
|
}
|
||
|
})(function () {
|
||
|
return (function t(e, i, n) {
|
||
|
function a(r, s) {
|
||
|
if (!i[r]) {
|
||
|
if (!e[r]) {
|
||
|
var l = "function" == typeof require && require;
|
||
|
if (!s && l) return l(r, !0);
|
||
|
if (o) return o(r, !0);
|
||
|
var u = new Error("Cannot find module '" + r + "'");
|
||
|
throw ((u.code = "MODULE_NOT_FOUND"), u);
|
||
|
}
|
||
|
var d = (i[r] = { exports: {} });
|
||
|
e[r][0].call(
|
||
|
d.exports,
|
||
|
function (t) {
|
||
|
var i = e[r][1][t];
|
||
|
return a(i || t);
|
||
|
},
|
||
|
d,
|
||
|
d.exports,
|
||
|
t,
|
||
|
e,
|
||
|
i,
|
||
|
n
|
||
|
);
|
||
|
}
|
||
|
return i[r].exports;
|
||
|
}
|
||
|
for (
|
||
|
var o = "function" == typeof require && require, r = 0;
|
||
|
r < n.length;
|
||
|
r++
|
||
|
)
|
||
|
a(n[r]);
|
||
|
return a;
|
||
|
})(
|
||
|
{
|
||
|
1: [function (t, e, i) {}, {}],
|
||
|
2: [
|
||
|
function (t, e, i) {
|
||
|
var n = t(6);
|
||
|
function a(t) {
|
||
|
if (t) {
|
||
|
var e = [0, 0, 0],
|
||
|
i = 1,
|
||
|
a = t.match(/^#([a-fA-F0-9]{3})$/i);
|
||
|
if (a) {
|
||
|
a = a[1];
|
||
|
for (var o = 0; o < e.length; o++)
|
||
|
e[o] = parseInt(a[o] + a[o], 16);
|
||
|
} else if ((a = t.match(/^#([a-fA-F0-9]{6})$/i))) {
|
||
|
a = a[1];
|
||
|
for (o = 0; o < e.length; o++)
|
||
|
e[o] = parseInt(a.slice(2 * o, 2 * o + 2), 16);
|
||
|
} else if (
|
||
|
(a = t.match(
|
||
|
/^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i
|
||
|
))
|
||
|
) {
|
||
|
for (o = 0; o < e.length; o++) e[o] = parseInt(a[o + 1]);
|
||
|
i = parseFloat(a[4]);
|
||
|
} else if (
|
||
|
(a = t.match(
|
||
|
/^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/i
|
||
|
))
|
||
|
) {
|
||
|
for (o = 0; o < e.length; o++)
|
||
|
e[o] = Math.round(2.55 * parseFloat(a[o + 1]));
|
||
|
i = parseFloat(a[4]);
|
||
|
} else if ((a = t.match(/(\w+)/))) {
|
||
|
if ("transparent" == a[1]) return [0, 0, 0, 0];
|
||
|
if (!(e = n[a[1]])) return;
|
||
|
}
|
||
|
for (o = 0; o < e.length; o++) e[o] = d(e[o], 0, 255);
|
||
|
return (i = i || 0 == i ? d(i, 0, 1) : 1), (e[3] = i), e;
|
||
|
}
|
||
|
}
|
||
|
function o(t) {
|
||
|
if (t) {
|
||
|
var e = t.match(
|
||
|
/^hsla?\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/
|
||
|
);
|
||
|
if (e) {
|
||
|
var i = parseFloat(e[4]);
|
||
|
return [
|
||
|
d(parseInt(e[1]), 0, 360),
|
||
|
d(parseFloat(e[2]), 0, 100),
|
||
|
d(parseFloat(e[3]), 0, 100),
|
||
|
d(isNaN(i) ? 1 : i, 0, 1),
|
||
|
];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
function r(t) {
|
||
|
if (t) {
|
||
|
var e = t.match(
|
||
|
/^hwb\(\s*([+-]?\d+)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)/
|
||
|
);
|
||
|
if (e) {
|
||
|
var i = parseFloat(e[4]);
|
||
|
return [
|
||
|
d(parseInt(e[1]), 0, 360),
|
||
|
d(parseFloat(e[2]), 0, 100),
|
||
|
d(parseFloat(e[3]), 0, 100),
|
||
|
d(isNaN(i) ? 1 : i, 0, 1),
|
||
|
];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
function s(t, e) {
|
||
|
return (
|
||
|
void 0 === e && (e = void 0 !== t[3] ? t[3] : 1),
|
||
|
"rgba(" + t[0] + ", " + t[1] + ", " + t[2] + ", " + e + ")"
|
||
|
);
|
||
|
}
|
||
|
function l(t, e) {
|
||
|
return (
|
||
|
"rgba(" +
|
||
|
Math.round((t[0] / 255) * 100) +
|
||
|
"%, " +
|
||
|
Math.round((t[1] / 255) * 100) +
|
||
|
"%, " +
|
||
|
Math.round((t[2] / 255) * 100) +
|
||
|
"%, " +
|
||
|
(e || t[3] || 1) +
|
||
|
")"
|
||
|
);
|
||
|
}
|
||
|
function u(t, e) {
|
||
|
return (
|
||
|
void 0 === e && (e = void 0 !== t[3] ? t[3] : 1),
|
||
|
"hsla(" + t[0] + ", " + t[1] + "%, " + t[2] + "%, " + e + ")"
|
||
|
);
|
||
|
}
|
||
|
function d(t, e, i) {
|
||
|
return Math.min(Math.max(e, t), i);
|
||
|
}
|
||
|
function c(t) {
|
||
|
var e = t.toString(16).toUpperCase();
|
||
|
return e.length < 2 ? "0" + e : e;
|
||
|
}
|
||
|
e.exports = {
|
||
|
getRgba: a,
|
||
|
getHsla: o,
|
||
|
getRgb: function (t) {
|
||
|
var e = a(t);
|
||
|
return e && e.slice(0, 3);
|
||
|
},
|
||
|
getHsl: function (t) {
|
||
|
var e = o(t);
|
||
|
return e && e.slice(0, 3);
|
||
|
},
|
||
|
getHwb: r,
|
||
|
getAlpha: function (t) {
|
||
|
var e = a(t);
|
||
|
{
|
||
|
if (e) return e[3];
|
||
|
if ((e = o(t))) return e[3];
|
||
|
if ((e = r(t))) return e[3];
|
||
|
}
|
||
|
},
|
||
|
hexString: function (t) {
|
||
|
return "#" + c(t[0]) + c(t[1]) + c(t[2]);
|
||
|
},
|
||
|
rgbString: function (t, e) {
|
||
|
if (e < 1 || (t[3] && t[3] < 1)) return s(t, e);
|
||
|
return "rgb(" + t[0] + ", " + t[1] + ", " + t[2] + ")";
|
||
|
},
|
||
|
rgbaString: s,
|
||
|
percentString: function (t, e) {
|
||
|
if (e < 1 || (t[3] && t[3] < 1)) return l(t, e);
|
||
|
var i = Math.round((t[0] / 255) * 100),
|
||
|
n = Math.round((t[1] / 255) * 100),
|
||
|
a = Math.round((t[2] / 255) * 100);
|
||
|
return "rgb(" + i + "%, " + n + "%, " + a + "%)";
|
||
|
},
|
||
|
percentaString: l,
|
||
|
hslString: function (t, e) {
|
||
|
if (e < 1 || (t[3] && t[3] < 1)) return u(t, e);
|
||
|
return "hsl(" + t[0] + ", " + t[1] + "%, " + t[2] + "%)";
|
||
|
},
|
||
|
hslaString: u,
|
||
|
hwbString: function (t, e) {
|
||
|
void 0 === e && (e = void 0 !== t[3] ? t[3] : 1);
|
||
|
return (
|
||
|
"hwb(" +
|
||
|
t[0] +
|
||
|
", " +
|
||
|
t[1] +
|
||
|
"%, " +
|
||
|
t[2] +
|
||
|
"%" +
|
||
|
(void 0 !== e && 1 !== e ? ", " + e : "") +
|
||
|
")"
|
||
|
);
|
||
|
},
|
||
|
keyword: function (t) {
|
||
|
return h[t.slice(0, 3)];
|
||
|
},
|
||
|
};
|
||
|
var h = {};
|
||
|
for (var f in n) h[n[f]] = f;
|
||
|
},
|
||
|
{ 6: 6 },
|
||
|
],
|
||
|
3: [
|
||
|
function (t, e, i) {
|
||
|
var n = t(5),
|
||
|
a = t(2),
|
||
|
o = function (t) {
|
||
|
return t instanceof o
|
||
|
? t
|
||
|
: this instanceof o
|
||
|
? ((this.valid = !1),
|
||
|
(this.values = {
|
||
|
rgb: [0, 0, 0],
|
||
|
hsl: [0, 0, 0],
|
||
|
hsv: [0, 0, 0],
|
||
|
hwb: [0, 0, 0],
|
||
|
cmyk: [0, 0, 0, 0],
|
||
|
alpha: 1,
|
||
|
}),
|
||
|
void ("string" == typeof t
|
||
|
? (e = a.getRgba(t))
|
||
|
? this.setValues("rgb", e)
|
||
|
: (e = a.getHsla(t))
|
||
|
? this.setValues("hsl", e)
|
||
|
: (e = a.getHwb(t)) && this.setValues("hwb", e)
|
||
|
: "object" == typeof t &&
|
||
|
(void 0 !== (e = t).r || void 0 !== e.red
|
||
|
? this.setValues("rgb", e)
|
||
|
: void 0 !== e.l || void 0 !== e.lightness
|
||
|
? this.setValues("hsl", e)
|
||
|
: void 0 !== e.v || void 0 !== e.value
|
||
|
? this.setValues("hsv", e)
|
||
|
: void 0 !== e.w || void 0 !== e.whiteness
|
||
|
? this.setValues("hwb", e)
|
||
|
: (void 0 === e.c && void 0 === e.cyan) ||
|
||
|
this.setValues("cmyk", e))))
|
||
|
: new o(t);
|
||
|
var e;
|
||
|
};
|
||
|
(o.prototype = {
|
||
|
isValid: function () {
|
||
|
return this.valid;
|
||
|
},
|
||
|
rgb: function () {
|
||
|
return this.setSpace("rgb", arguments);
|
||
|
},
|
||
|
hsl: function () {
|
||
|
return this.setSpace("hsl", arguments);
|
||
|
},
|
||
|
hsv: function () {
|
||
|
return this.setSpace("hsv", arguments);
|
||
|
},
|
||
|
hwb: function () {
|
||
|
return this.setSpace("hwb", arguments);
|
||
|
},
|
||
|
cmyk: function () {
|
||
|
return this.setSpace("cmyk", arguments);
|
||
|
},
|
||
|
rgbArray: function () {
|
||
|
return this.values.rgb;
|
||
|
},
|
||
|
hslArray: function () {
|
||
|
return this.values.hsl;
|
||
|
},
|
||
|
hsvArray: function () {
|
||
|
return this.values.hsv;
|
||
|
},
|
||
|
hwbArray: function () {
|
||
|
var t = this.values;
|
||
|
return 1 !== t.alpha ? t.hwb.concat([t.alpha]) : t.hwb;
|
||
|
},
|
||
|
cmykArray: function () {
|
||
|
return this.values.cmyk;
|
||
|
},
|
||
|
rgbaArray: function () {
|
||
|
var t = this.values;
|
||
|
return t.rgb.concat([t.alpha]);
|
||
|
},
|
||
|
hslaArray: function () {
|
||
|
var t = this.values;
|
||
|
return t.hsl.concat([t.alpha]);
|
||
|
},
|
||
|
alpha: function (t) {
|
||
|
return void 0 === t
|
||
|
? this.values.alpha
|
||
|
: (this.setValues("alpha", t), this);
|
||
|
},
|
||
|
red: function (t) {
|
||
|
return this.setChannel("rgb", 0, t);
|
||
|
},
|
||
|
green: function (t) {
|
||
|
return this.setChannel("rgb", 1, t);
|
||
|
},
|
||
|
blue: function (t) {
|
||
|
return this.setChannel("rgb", 2, t);
|
||
|
},
|
||
|
hue: function (t) {
|
||
|
return (
|
||
|
t && (t = (t %= 360) < 0 ? 360 + t : t),
|
||
|
this.setChannel("hsl", 0, t)
|
||
|
);
|
||
|
},
|
||
|
saturation: function (t) {
|
||
|
return this.setChannel("hsl", 1, t);
|
||
|
},
|
||
|
lightness: function (t) {
|
||
|
return this.setChannel("hsl", 2, t);
|
||
|
},
|
||
|
saturationv: function (t) {
|
||
|
return this.setChannel("hsv", 1, t);
|
||
|
},
|
||
|
whiteness: function (t) {
|
||
|
return this.setChannel("hwb", 1, t);
|
||
|
},
|
||
|
blackness: function (t) {
|
||
|
return this.setChannel("hwb", 2, t);
|
||
|
},
|
||
|
value: function (t) {
|
||
|
return this.setChannel("hsv", 2, t);
|
||
|
},
|
||
|
cyan: function (t) {
|
||
|
return this.setChannel("cmyk", 0, t);
|
||
|
},
|
||
|
magenta: function (t) {
|
||
|
return this.setChannel("cmyk", 1, t);
|
||
|
},
|
||
|
yellow: function (t) {
|
||
|
return this.setChannel("cmyk", 2, t);
|
||
|
},
|
||
|
black: function (t) {
|
||
|
return this.setChannel("cmyk", 3, t);
|
||
|
},
|
||
|
hexString: function () {
|
||
|
return a.hexString(this.values.rgb);
|
||
|
},
|
||
|
rgbString: function () {
|
||
|
return a.rgbString(this.values.rgb, this.values.alpha);
|
||
|
},
|
||
|
rgbaString: function () {
|
||
|
return a.rgbaString(this.values.rgb, this.values.alpha);
|
||
|
},
|
||
|
percentString: function () {
|
||
|
return a.percentString(this.values.rgb, this.values.alpha);
|
||
|
},
|
||
|
hslString: function () {
|
||
|
return a.hslString(this.values.hsl, this.values.alpha);
|
||
|
},
|
||
|
hslaString: function () {
|
||
|
return a.hslaString(this.values.hsl, this.values.alpha);
|
||
|
},
|
||
|
hwbString: function () {
|
||
|
return a.hwbString(this.values.hwb, this.values.alpha);
|
||
|
},
|
||
|
keyword: function () {
|
||
|
return a.keyword(this.values.rgb, this.values.alpha);
|
||
|
},
|
||
|
rgbNumber: function () {
|
||
|
var t = this.values.rgb;
|
||
|
return (t[0] << 16) | (t[1] << 8) | t[2];
|
||
|
},
|
||
|
luminosity: function () {
|
||
|
for (var t = this.values.rgb, e = [], i = 0; i < t.length; i++) {
|
||
|
var n = t[i] / 255;
|
||
|
e[i] =
|
||
|
n <= 0.03928 ? n / 12.92 : Math.pow((n + 0.055) / 1.055, 2.4);
|
||
|
}
|
||
|
return 0.2126 * e[0] + 0.7152 * e[1] + 0.0722 * e[2];
|
||
|
},
|
||
|
contrast: function (t) {
|
||
|
var e = this.luminosity(),
|
||
|
i = t.luminosity();
|
||
|
return e > i ? (e + 0.05) / (i + 0.05) : (i + 0.05) / (e + 0.05);
|
||
|
},
|
||
|
level: function (t) {
|
||
|
var e = this.contrast(t);
|
||
|
return e >= 7.1 ? "AAA" : e >= 4.5 ? "AA" : "";
|
||
|
},
|
||
|
dark: function () {
|
||
|
var t = this.values.rgb;
|
||
|
return (299 * t[0] + 587 * t[1] + 114 * t[2]) / 1e3 < 128;
|
||
|
},
|
||
|
light: function () {
|
||
|
return !this.dark();
|
||
|
},
|
||
|
negate: function () {
|
||
|
for (var t = [], e = 0; e < 3; e++)
|
||
|
t[e] = 255 - this.values.rgb[e];
|
||
|
return this.setValues("rgb", t), this;
|
||
|
},
|
||
|
lighten: function (t) {
|
||
|
var e = this.values.hsl;
|
||
|
return (e[2] += e[2] * t), this.setValues("hsl", e), this;
|
||
|
},
|
||
|
darken: function (t) {
|
||
|
var e = this.values.hsl;
|
||
|
return (e[2] -= e[2] * t), this.setValues("hsl", e), this;
|
||
|
},
|
||
|
saturate: function (t) {
|
||
|
var e = this.values.hsl;
|
||
|
return (e[1] += e[1] * t), this.setValues("hsl", e), this;
|
||
|
},
|
||
|
desaturate: function (t) {
|
||
|
var e = this.values.hsl;
|
||
|
return (e[1] -= e[1] * t), this.setValues("hsl", e), this;
|
||
|
},
|
||
|
whiten: function (t) {
|
||
|
var e = this.values.hwb;
|
||
|
return (e[1] += e[1] * t), this.setValues("hwb", e), this;
|
||
|
},
|
||
|
blacken: function (t) {
|
||
|
var e = this.values.hwb;
|
||
|
return (e[2] += e[2] * t), this.setValues("hwb", e), this;
|
||
|
},
|
||
|
greyscale: function () {
|
||
|
var t = this.values.rgb,
|
||
|
e = 0.3 * t[0] + 0.59 * t[1] + 0.11 * t[2];
|
||
|
return this.setValues("rgb", [e, e, e]), this;
|
||
|
},
|
||
|
clearer: function (t) {
|
||
|
var e = this.values.alpha;
|
||
|
return this.setValues("alpha", e - e * t), this;
|
||
|
},
|
||
|
opaquer: function (t) {
|
||
|
var e = this.values.alpha;
|
||
|
return this.setValues("alpha", e + e * t), this;
|
||
|
},
|
||
|
rotate: function (t) {
|
||
|
var e = this.values.hsl,
|
||
|
i = (e[0] + t) % 360;
|
||
|
return (
|
||
|
(e[0] = i < 0 ? 360 + i : i), this.setValues("hsl", e), this
|
||
|
);
|
||
|
},
|
||
|
mix: function (t, e) {
|
||
|
var i = this,
|
||
|
n = t,
|
||
|
a = void 0 === e ? 0.5 : e,
|
||
|
o = 2 * a - 1,
|
||
|
r = i.alpha() - n.alpha(),
|
||
|
s = ((o * r == -1 ? o : (o + r) / (1 + o * r)) + 1) / 2,
|
||
|
l = 1 - s;
|
||
|
return this.rgb(
|
||
|
s * i.red() + l * n.red(),
|
||
|
s * i.green() + l * n.green(),
|
||
|
s * i.blue() + l * n.blue()
|
||
|
).alpha(i.alpha() * a + n.alpha() * (1 - a));
|
||
|
},
|
||
|
toJSON: function () {
|
||
|
return this.rgb();
|
||
|
},
|
||
|
clone: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i = new o(),
|
||
|
n = this.values,
|
||
|
a = i.values;
|
||
|
for (var r in n)
|
||
|
n.hasOwnProperty(r) &&
|
||
|
((t = n[r]),
|
||
|
"[object Array]" === (e = {}.toString.call(t))
|
||
|
? (a[r] = t.slice(0))
|
||
|
: "[object Number]" === e
|
||
|
? (a[r] = t)
|
||
|
: console.error("unexpected color value:", t));
|
||
|
return i;
|
||
|
},
|
||
|
}),
|
||
|
(o.prototype.spaces = {
|
||
|
rgb: ["red", "green", "blue"],
|
||
|
hsl: ["hue", "saturation", "lightness"],
|
||
|
hsv: ["hue", "saturation", "value"],
|
||
|
hwb: ["hue", "whiteness", "blackness"],
|
||
|
cmyk: ["cyan", "magenta", "yellow", "black"],
|
||
|
}),
|
||
|
(o.prototype.maxes = {
|
||
|
rgb: [255, 255, 255],
|
||
|
hsl: [360, 100, 100],
|
||
|
hsv: [360, 100, 100],
|
||
|
hwb: [360, 100, 100],
|
||
|
cmyk: [100, 100, 100, 100],
|
||
|
}),
|
||
|
(o.prototype.getValues = function (t) {
|
||
|
for (var e = this.values, i = {}, n = 0; n < t.length; n++)
|
||
|
i[t.charAt(n)] = e[t][n];
|
||
|
return 1 !== e.alpha && (i.a = e.alpha), i;
|
||
|
}),
|
||
|
(o.prototype.setValues = function (t, e) {
|
||
|
var i,
|
||
|
a,
|
||
|
o = this.values,
|
||
|
r = this.spaces,
|
||
|
s = this.maxes,
|
||
|
l = 1;
|
||
|
if (((this.valid = !0), "alpha" === t)) l = e;
|
||
|
else if (e.length)
|
||
|
(o[t] = e.slice(0, t.length)), (l = e[t.length]);
|
||
|
else if (void 0 !== e[t.charAt(0)]) {
|
||
|
for (i = 0; i < t.length; i++) o[t][i] = e[t.charAt(i)];
|
||
|
l = e.a;
|
||
|
} else if (void 0 !== e[r[t][0]]) {
|
||
|
var u = r[t];
|
||
|
for (i = 0; i < t.length; i++) o[t][i] = e[u[i]];
|
||
|
l = e.alpha;
|
||
|
}
|
||
|
if (
|
||
|
((o.alpha = Math.max(
|
||
|
0,
|
||
|
Math.min(1, void 0 === l ? o.alpha : l)
|
||
|
)),
|
||
|
"alpha" === t)
|
||
|
)
|
||
|
return !1;
|
||
|
for (i = 0; i < t.length; i++)
|
||
|
(a = Math.max(0, Math.min(s[t][i], o[t][i]))),
|
||
|
(o[t][i] = Math.round(a));
|
||
|
for (var d in r) d !== t && (o[d] = n[t][d](o[t]));
|
||
|
return !0;
|
||
|
}),
|
||
|
(o.prototype.setSpace = function (t, e) {
|
||
|
var i = e[0];
|
||
|
return void 0 === i
|
||
|
? this.getValues(t)
|
||
|
: ("number" == typeof i && (i = Array.prototype.slice.call(e)),
|
||
|
this.setValues(t, i),
|
||
|
this);
|
||
|
}),
|
||
|
(o.prototype.setChannel = function (t, e, i) {
|
||
|
var n = this.values[t];
|
||
|
return void 0 === i
|
||
|
? n[e]
|
||
|
: i === n[e]
|
||
|
? this
|
||
|
: ((n[e] = i), this.setValues(t, n), this);
|
||
|
}),
|
||
|
"undefined" != typeof window && (window.Color = o),
|
||
|
(e.exports = o);
|
||
|
},
|
||
|
{ 2: 2, 5: 5 },
|
||
|
],
|
||
|
4: [
|
||
|
function (t, e, i) {
|
||
|
function n(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n = t[0] / 255,
|
||
|
a = t[1] / 255,
|
||
|
o = t[2] / 255,
|
||
|
r = Math.min(n, a, o),
|
||
|
s = Math.max(n, a, o),
|
||
|
l = s - r;
|
||
|
return (
|
||
|
s == r
|
||
|
? (e = 0)
|
||
|
: n == s
|
||
|
? (e = (a - o) / l)
|
||
|
: a == s
|
||
|
? (e = 2 + (o - n) / l)
|
||
|
: o == s && (e = 4 + (n - a) / l),
|
||
|
(e = Math.min(60 * e, 360)) < 0 && (e += 360),
|
||
|
(i = (r + s) / 2),
|
||
|
[
|
||
|
e,
|
||
|
100 * (s == r ? 0 : i <= 0.5 ? l / (s + r) : l / (2 - s - r)),
|
||
|
100 * i,
|
||
|
]
|
||
|
);
|
||
|
}
|
||
|
function a(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n = t[0],
|
||
|
a = t[1],
|
||
|
o = t[2],
|
||
|
r = Math.min(n, a, o),
|
||
|
s = Math.max(n, a, o),
|
||
|
l = s - r;
|
||
|
return (
|
||
|
(i = 0 == s ? 0 : ((l / s) * 1e3) / 10),
|
||
|
s == r
|
||
|
? (e = 0)
|
||
|
: n == s
|
||
|
? (e = (a - o) / l)
|
||
|
: a == s
|
||
|
? (e = 2 + (o - n) / l)
|
||
|
: o == s && (e = 4 + (n - a) / l),
|
||
|
(e = Math.min(60 * e, 360)) < 0 && (e += 360),
|
||
|
[e, i, ((s / 255) * 1e3) / 10]
|
||
|
);
|
||
|
}
|
||
|
function o(t) {
|
||
|
var e = t[0],
|
||
|
i = t[1],
|
||
|
a = t[2];
|
||
|
return [
|
||
|
n(t)[0],
|
||
|
100 * ((1 / 255) * Math.min(e, Math.min(i, a))),
|
||
|
100 * (a = 1 - (1 / 255) * Math.max(e, Math.max(i, a))),
|
||
|
];
|
||
|
}
|
||
|
function s(t) {
|
||
|
var e,
|
||
|
i = t[0] / 255,
|
||
|
n = t[1] / 255,
|
||
|
a = t[2] / 255;
|
||
|
return [
|
||
|
100 *
|
||
|
((1 - i - (e = Math.min(1 - i, 1 - n, 1 - a))) / (1 - e) || 0),
|
||
|
100 * ((1 - n - e) / (1 - e) || 0),
|
||
|
100 * ((1 - a - e) / (1 - e) || 0),
|
||
|
100 * e,
|
||
|
];
|
||
|
}
|
||
|
function l(t) {
|
||
|
return C[JSON.stringify(t)];
|
||
|
}
|
||
|
function u(t) {
|
||
|
var e = t[0] / 255,
|
||
|
i = t[1] / 255,
|
||
|
n = t[2] / 255;
|
||
|
return [
|
||
|
100 *
|
||
|
(0.4124 *
|
||
|
(e =
|
||
|
e > 0.04045
|
||
|
? Math.pow((e + 0.055) / 1.055, 2.4)
|
||
|
: e / 12.92) +
|
||
|
0.3576 *
|
||
|
(i =
|
||
|
i > 0.04045
|
||
|
? Math.pow((i + 0.055) / 1.055, 2.4)
|
||
|
: i / 12.92) +
|
||
|
0.1805 *
|
||
|
(n =
|
||
|
n > 0.04045
|
||
|
? Math.pow((n + 0.055) / 1.055, 2.4)
|
||
|
: n / 12.92)),
|
||
|
100 * (0.2126 * e + 0.7152 * i + 0.0722 * n),
|
||
|
100 * (0.0193 * e + 0.1192 * i + 0.9505 * n),
|
||
|
];
|
||
|
}
|
||
|
function d(t) {
|
||
|
var e = u(t),
|
||
|
i = e[0],
|
||
|
n = e[1],
|
||
|
a = e[2];
|
||
|
return (
|
||
|
(n /= 100),
|
||
|
(a /= 108.883),
|
||
|
(i =
|
||
|
(i /= 95.047) > 0.008856
|
||
|
? Math.pow(i, 1 / 3)
|
||
|
: 7.787 * i + 16 / 116),
|
||
|
[
|
||
|
116 *
|
||
|
(n =
|
||
|
n > 0.008856 ? Math.pow(n, 1 / 3) : 7.787 * n + 16 / 116) -
|
||
|
16,
|
||
|
500 * (i - n),
|
||
|
200 *
|
||
|
(n -
|
||
|
(a =
|
||
|
a > 0.008856
|
||
|
? Math.pow(a, 1 / 3)
|
||
|
: 7.787 * a + 16 / 116)),
|
||
|
]
|
||
|
);
|
||
|
}
|
||
|
function c(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
a,
|
||
|
o,
|
||
|
r = t[0] / 360,
|
||
|
s = t[1] / 100,
|
||
|
l = t[2] / 100;
|
||
|
if (0 == s) return [(o = 255 * l), o, o];
|
||
|
(e = 2 * l - (i = l < 0.5 ? l * (1 + s) : l + s - l * s)),
|
||
|
(a = [0, 0, 0]);
|
||
|
for (var u = 0; u < 3; u++)
|
||
|
(n = r + (1 / 3) * -(u - 1)) < 0 && n++,
|
||
|
n > 1 && n--,
|
||
|
(o =
|
||
|
6 * n < 1
|
||
|
? e + 6 * (i - e) * n
|
||
|
: 2 * n < 1
|
||
|
? i
|
||
|
: 3 * n < 2
|
||
|
? e + (i - e) * (2 / 3 - n) * 6
|
||
|
: e),
|
||
|
(a[u] = 255 * o);
|
||
|
return a;
|
||
|
}
|
||
|
function h(t) {
|
||
|
var e = t[0] / 60,
|
||
|
i = t[1] / 100,
|
||
|
n = t[2] / 100,
|
||
|
a = Math.floor(e) % 6,
|
||
|
o = e - Math.floor(e),
|
||
|
r = 255 * n * (1 - i),
|
||
|
s = 255 * n * (1 - i * o),
|
||
|
l = 255 * n * (1 - i * (1 - o));
|
||
|
n *= 255;
|
||
|
switch (a) {
|
||
|
case 0:
|
||
|
return [n, l, r];
|
||
|
case 1:
|
||
|
return [s, n, r];
|
||
|
case 2:
|
||
|
return [r, n, l];
|
||
|
case 3:
|
||
|
return [r, s, n];
|
||
|
case 4:
|
||
|
return [l, r, n];
|
||
|
case 5:
|
||
|
return [n, r, s];
|
||
|
}
|
||
|
}
|
||
|
function f(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
a,
|
||
|
o = t[0] / 360,
|
||
|
s = t[1] / 100,
|
||
|
l = t[2] / 100,
|
||
|
u = s + l;
|
||
|
switch (
|
||
|
(u > 1 && ((s /= u), (l /= u)),
|
||
|
(n = 6 * o - (e = Math.floor(6 * o))),
|
||
|
0 != (1 & e) && (n = 1 - n),
|
||
|
(a = s + n * ((i = 1 - l) - s)),
|
||
|
e)
|
||
|
) {
|
||
|
default:
|
||
|
case 6:
|
||
|
case 0:
|
||
|
(r = i), (g = a), (b = s);
|
||
|
break;
|
||
|
case 1:
|
||
|
(r = a), (g = i), (b = s);
|
||
|
break;
|
||
|
case 2:
|
||
|
(r = s), (g = i), (b = a);
|
||
|
break;
|
||
|
case 3:
|
||
|
(r = s), (g = a), (b = i);
|
||
|
break;
|
||
|
case 4:
|
||
|
(r = a), (g = s), (b = i);
|
||
|
break;
|
||
|
case 5:
|
||
|
(r = i), (g = s), (b = a);
|
||
|
}
|
||
|
return [255 * r, 255 * g, 255 * b];
|
||
|
}
|
||
|
function p(t) {
|
||
|
var e = t[0] / 100,
|
||
|
i = t[1] / 100,
|
||
|
n = t[2] / 100,
|
||
|
a = t[3] / 100;
|
||
|
return [
|
||
|
255 * (1 - Math.min(1, e * (1 - a) + a)),
|
||
|
255 * (1 - Math.min(1, i * (1 - a) + a)),
|
||
|
255 * (1 - Math.min(1, n * (1 - a) + a)),
|
||
|
];
|
||
|
}
|
||
|
function m(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
a = t[0] / 100,
|
||
|
o = t[1] / 100,
|
||
|
r = t[2] / 100;
|
||
|
return (
|
||
|
(i = -0.9689 * a + 1.8758 * o + 0.0415 * r),
|
||
|
(n = 0.0557 * a + -0.204 * o + 1.057 * r),
|
||
|
(e =
|
||
|
(e = 3.2406 * a + -1.5372 * o + -0.4986 * r) > 0.0031308
|
||
|
? 1.055 * Math.pow(e, 1 / 2.4) - 0.055
|
||
|
: (e *= 12.92)),
|
||
|
(i =
|
||
|
i > 0.0031308
|
||
|
? 1.055 * Math.pow(i, 1 / 2.4) - 0.055
|
||
|
: (i *= 12.92)),
|
||
|
(n =
|
||
|
n > 0.0031308
|
||
|
? 1.055 * Math.pow(n, 1 / 2.4) - 0.055
|
||
|
: (n *= 12.92)),
|
||
|
[
|
||
|
255 * (e = Math.min(Math.max(0, e), 1)),
|
||
|
255 * (i = Math.min(Math.max(0, i), 1)),
|
||
|
255 * (n = Math.min(Math.max(0, n), 1)),
|
||
|
]
|
||
|
);
|
||
|
}
|
||
|
function v(t) {
|
||
|
var e = t[0],
|
||
|
i = t[1],
|
||
|
n = t[2];
|
||
|
return (
|
||
|
(i /= 100),
|
||
|
(n /= 108.883),
|
||
|
(e =
|
||
|
(e /= 95.047) > 0.008856
|
||
|
? Math.pow(e, 1 / 3)
|
||
|
: 7.787 * e + 16 / 116),
|
||
|
[
|
||
|
116 *
|
||
|
(i =
|
||
|
i > 0.008856 ? Math.pow(i, 1 / 3) : 7.787 * i + 16 / 116) -
|
||
|
16,
|
||
|
500 * (e - i),
|
||
|
200 *
|
||
|
(i -
|
||
|
(n =
|
||
|
n > 0.008856
|
||
|
? Math.pow(n, 1 / 3)
|
||
|
: 7.787 * n + 16 / 116)),
|
||
|
]
|
||
|
);
|
||
|
}
|
||
|
function x(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
a,
|
||
|
o = t[0],
|
||
|
r = t[1],
|
||
|
s = t[2];
|
||
|
return (
|
||
|
o <= 8
|
||
|
? (a = ((i = (100 * o) / 903.3) / 100) * 7.787 + 16 / 116)
|
||
|
: ((i = 100 * Math.pow((o + 16) / 116, 3)),
|
||
|
(a = Math.pow(i / 100, 1 / 3))),
|
||
|
[
|
||
|
(e =
|
||
|
e / 95.047 <= 0.008856
|
||
|
? (e = (95.047 * (r / 500 + a - 16 / 116)) / 7.787)
|
||
|
: 95.047 * Math.pow(r / 500 + a, 3)),
|
||
|
i,
|
||
|
(n =
|
||
|
n / 108.883 <= 0.008859
|
||
|
? (n = (108.883 * (a - s / 200 - 16 / 116)) / 7.787)
|
||
|
: 108.883 * Math.pow(a - s / 200, 3)),
|
||
|
]
|
||
|
);
|
||
|
}
|
||
|
function y(t) {
|
||
|
var e,
|
||
|
i = t[0],
|
||
|
n = t[1],
|
||
|
a = t[2];
|
||
|
return (
|
||
|
(e = (360 * Math.atan2(a, n)) / 2 / Math.PI) < 0 && (e += 360),
|
||
|
[i, Math.sqrt(n * n + a * a), e]
|
||
|
);
|
||
|
}
|
||
|
function k(t) {
|
||
|
return m(x(t));
|
||
|
}
|
||
|
function M(t) {
|
||
|
var e,
|
||
|
i = t[0],
|
||
|
n = t[1];
|
||
|
return (
|
||
|
(e = (t[2] / 360) * 2 * Math.PI),
|
||
|
[i, n * Math.cos(e), n * Math.sin(e)]
|
||
|
);
|
||
|
}
|
||
|
function w(t) {
|
||
|
return S[t];
|
||
|
}
|
||
|
e.exports = {
|
||
|
rgb2hsl: n,
|
||
|
rgb2hsv: a,
|
||
|
rgb2hwb: o,
|
||
|
rgb2cmyk: s,
|
||
|
rgb2keyword: l,
|
||
|
rgb2xyz: u,
|
||
|
rgb2lab: d,
|
||
|
rgb2lch: function (t) {
|
||
|
return y(d(t));
|
||
|
},
|
||
|
hsl2rgb: c,
|
||
|
hsl2hsv: function (t) {
|
||
|
var e = t[0],
|
||
|
i = t[1] / 100,
|
||
|
n = t[2] / 100;
|
||
|
if (0 === n) return [0, 0, 0];
|
||
|
return [
|
||
|
e,
|
||
|
100 * ((2 * (i *= (n *= 2) <= 1 ? n : 2 - n)) / (n + i)),
|
||
|
100 * ((n + i) / 2),
|
||
|
];
|
||
|
},
|
||
|
hsl2hwb: function (t) {
|
||
|
return o(c(t));
|
||
|
},
|
||
|
hsl2cmyk: function (t) {
|
||
|
return s(c(t));
|
||
|
},
|
||
|
hsl2keyword: function (t) {
|
||
|
return l(c(t));
|
||
|
},
|
||
|
hsv2rgb: h,
|
||
|
hsv2hsl: function (t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n = t[0],
|
||
|
a = t[1] / 100,
|
||
|
o = t[2] / 100;
|
||
|
return (
|
||
|
(e = a * o),
|
||
|
[
|
||
|
n,
|
||
|
100 * (e = (e /= (i = (2 - a) * o) <= 1 ? i : 2 - i) || 0),
|
||
|
100 * (i /= 2),
|
||
|
]
|
||
|
);
|
||
|
},
|
||
|
hsv2hwb: function (t) {
|
||
|
return o(h(t));
|
||
|
},
|
||
|
hsv2cmyk: function (t) {
|
||
|
return s(h(t));
|
||
|
},
|
||
|
hsv2keyword: function (t) {
|
||
|
return l(h(t));
|
||
|
},
|
||
|
hwb2rgb: f,
|
||
|
hwb2hsl: function (t) {
|
||
|
return n(f(t));
|
||
|
},
|
||
|
hwb2hsv: function (t) {
|
||
|
return a(f(t));
|
||
|
},
|
||
|
hwb2cmyk: function (t) {
|
||
|
return s(f(t));
|
||
|
},
|
||
|
hwb2keyword: function (t) {
|
||
|
return l(f(t));
|
||
|
},
|
||
|
cmyk2rgb: p,
|
||
|
cmyk2hsl: function (t) {
|
||
|
return n(p(t));
|
||
|
},
|
||
|
cmyk2hsv: function (t) {
|
||
|
return a(p(t));
|
||
|
},
|
||
|
cmyk2hwb: function (t) {
|
||
|
return o(p(t));
|
||
|
},
|
||
|
cmyk2keyword: function (t) {
|
||
|
return l(p(t));
|
||
|
},
|
||
|
keyword2rgb: w,
|
||
|
keyword2hsl: function (t) {
|
||
|
return n(w(t));
|
||
|
},
|
||
|
keyword2hsv: function (t) {
|
||
|
return a(w(t));
|
||
|
},
|
||
|
keyword2hwb: function (t) {
|
||
|
return o(w(t));
|
||
|
},
|
||
|
keyword2cmyk: function (t) {
|
||
|
return s(w(t));
|
||
|
},
|
||
|
keyword2lab: function (t) {
|
||
|
return d(w(t));
|
||
|
},
|
||
|
keyword2xyz: function (t) {
|
||
|
return u(w(t));
|
||
|
},
|
||
|
xyz2rgb: m,
|
||
|
xyz2lab: v,
|
||
|
xyz2lch: function (t) {
|
||
|
return y(v(t));
|
||
|
},
|
||
|
lab2xyz: x,
|
||
|
lab2rgb: k,
|
||
|
lab2lch: y,
|
||
|
lch2lab: M,
|
||
|
lch2xyz: function (t) {
|
||
|
return x(M(t));
|
||
|
},
|
||
|
lch2rgb: function (t) {
|
||
|
return k(M(t));
|
||
|
},
|
||
|
};
|
||
|
var S = {
|
||
|
aliceblue: [240, 248, 255],
|
||
|
antiquewhite: [250, 235, 215],
|
||
|
aqua: [0, 255, 255],
|
||
|
aquamarine: [127, 255, 212],
|
||
|
azure: [240, 255, 255],
|
||
|
beige: [245, 245, 220],
|
||
|
bisque: [255, 228, 196],
|
||
|
black: [0, 0, 0],
|
||
|
blanchedalmond: [255, 235, 205],
|
||
|
blue: [0, 0, 255],
|
||
|
blueviolet: [138, 43, 226],
|
||
|
brown: [165, 42, 42],
|
||
|
burlywood: [222, 184, 135],
|
||
|
cadetblue: [95, 158, 160],
|
||
|
chartreuse: [127, 255, 0],
|
||
|
chocolate: [210, 105, 30],
|
||
|
coral: [255, 127, 80],
|
||
|
cornflowerblue: [100, 149, 237],
|
||
|
cornsilk: [255, 248, 220],
|
||
|
crimson: [220, 20, 60],
|
||
|
cyan: [0, 255, 255],
|
||
|
darkblue: [0, 0, 139],
|
||
|
darkcyan: [0, 139, 139],
|
||
|
darkgoldenrod: [184, 134, 11],
|
||
|
darkgray: [169, 169, 169],
|
||
|
darkgreen: [0, 100, 0],
|
||
|
darkgrey: [169, 169, 169],
|
||
|
darkkhaki: [189, 183, 107],
|
||
|
darkmagenta: [139, 0, 139],
|
||
|
darkolivegreen: [85, 107, 47],
|
||
|
darkorange: [255, 140, 0],
|
||
|
darkorchid: [153, 50, 204],
|
||
|
darkred: [139, 0, 0],
|
||
|
darksalmon: [233, 150, 122],
|
||
|
darkseagreen: [143, 188, 143],
|
||
|
darkslateblue: [72, 61, 139],
|
||
|
darkslategray: [47, 79, 79],
|
||
|
darkslategrey: [47, 79, 79],
|
||
|
darkturquoise: [0, 206, 209],
|
||
|
darkviolet: [148, 0, 211],
|
||
|
deeppink: [255, 20, 147],
|
||
|
deepskyblue: [0, 191, 255],
|
||
|
dimgray: [105, 105, 105],
|
||
|
dimgrey: [105, 105, 105],
|
||
|
dodgerblue: [30, 144, 255],
|
||
|
firebrick: [178, 34, 34],
|
||
|
floralwhite: [255, 250, 240],
|
||
|
forestgreen: [34, 139, 34],
|
||
|
fuchsia: [255, 0, 255],
|
||
|
gainsboro: [220, 220, 220],
|
||
|
ghostwhite: [248, 248, 255],
|
||
|
gold: [255, 215, 0],
|
||
|
goldenrod: [218, 165, 32],
|
||
|
gray: [128, 128, 128],
|
||
|
green: [0, 128, 0],
|
||
|
greenyellow: [173, 255, 47],
|
||
|
grey: [128, 128, 128],
|
||
|
honeydew: [240, 255, 240],
|
||
|
hotpink: [255, 105, 180],
|
||
|
indianred: [205, 92, 92],
|
||
|
indigo: [75, 0, 130],
|
||
|
ivory: [255, 255, 240],
|
||
|
khaki: [240, 230, 140],
|
||
|
lavender: [230, 230, 250],
|
||
|
lavenderblush: [255, 240, 245],
|
||
|
lawngreen: [124, 252, 0],
|
||
|
lemonchiffon: [255, 250, 205],
|
||
|
lightblue: [173, 216, 230],
|
||
|
lightcoral: [240, 128, 128],
|
||
|
lightcyan: [224, 255, 255],
|
||
|
lightgoldenrodyellow: [250, 250, 210],
|
||
|
lightgray: [211, 211, 211],
|
||
|
lightgreen: [144, 238, 144],
|
||
|
lightgrey: [211, 211, 211],
|
||
|
lightpink: [255, 182, 193],
|
||
|
lightsalmon: [255, 160, 122],
|
||
|
lightseagreen: [32, 178, 170],
|
||
|
lightskyblue: [135, 206, 250],
|
||
|
lightslategray: [119, 136, 153],
|
||
|
lightslategrey: [119, 136, 153],
|
||
|
lightsteelblue: [176, 196, 222],
|
||
|
lightyellow: [255, 255, 224],
|
||
|
lime: [0, 255, 0],
|
||
|
limegreen: [50, 205, 50],
|
||
|
linen: [250, 240, 230],
|
||
|
magenta: [255, 0, 255],
|
||
|
maroon: [128, 0, 0],
|
||
|
mediumaquamarine: [102, 205, 170],
|
||
|
mediumblue: [0, 0, 205],
|
||
|
mediumorchid: [186, 85, 211],
|
||
|
mediumpurple: [147, 112, 219],
|
||
|
mediumseagreen: [60, 179, 113],
|
||
|
mediumslateblue: [123, 104, 238],
|
||
|
mediumspringgreen: [0, 250, 154],
|
||
|
mediumturquoise: [72, 209, 204],
|
||
|
mediumvioletred: [199, 21, 133],
|
||
|
midnightblue: [25, 25, 112],
|
||
|
mintcream: [245, 255, 250],
|
||
|
mistyrose: [255, 228, 225],
|
||
|
moccasin: [255, 228, 181],
|
||
|
navajowhite: [255, 222, 173],
|
||
|
navy: [0, 0, 128],
|
||
|
oldlace: [253, 245, 230],
|
||
|
olive: [128, 128, 0],
|
||
|
olivedrab: [107, 142, 35],
|
||
|
orange: [255, 165, 0],
|
||
|
orangered: [255, 69, 0],
|
||
|
orchid: [218, 112, 214],
|
||
|
palegoldenrod: [238, 232, 170],
|
||
|
palegreen: [152, 251, 152],
|
||
|
paleturquoise: [175, 238, 238],
|
||
|
palevioletred: [219, 112, 147],
|
||
|
papayawhip: [255, 239, 213],
|
||
|
peachpuff: [255, 218, 185],
|
||
|
peru: [205, 133, 63],
|
||
|
pink: [255, 192, 203],
|
||
|
plum: [221, 160, 221],
|
||
|
powderblue: [176, 224, 230],
|
||
|
purple: [128, 0, 128],
|
||
|
rebeccapurple: [102, 51, 153],
|
||
|
red: [255, 0, 0],
|
||
|
rosybrown: [188, 143, 143],
|
||
|
royalblue: [65, 105, 225],
|
||
|
saddlebrown: [139, 69, 19],
|
||
|
salmon: [250, 128, 114],
|
||
|
sandybrown: [244, 164, 96],
|
||
|
seagreen: [46, 139, 87],
|
||
|
seashell: [255, 245, 238],
|
||
|
sienna: [160, 82, 45],
|
||
|
silver: [192, 192, 192],
|
||
|
skyblue: [135, 206, 235],
|
||
|
slateblue: [106, 90, 205],
|
||
|
slategray: [112, 128, 144],
|
||
|
slategrey: [112, 128, 144],
|
||
|
snow: [255, 250, 250],
|
||
|
springgreen: [0, 255, 127],
|
||
|
steelblue: [70, 130, 180],
|
||
|
tan: [210, 180, 140],
|
||
|
teal: [0, 128, 128],
|
||
|
thistle: [216, 191, 216],
|
||
|
tomato: [255, 99, 71],
|
||
|
turquoise: [64, 224, 208],
|
||
|
violet: [238, 130, 238],
|
||
|
wheat: [245, 222, 179],
|
||
|
white: [255, 255, 255],
|
||
|
whitesmoke: [245, 245, 245],
|
||
|
yellow: [255, 255, 0],
|
||
|
yellowgreen: [154, 205, 50],
|
||
|
},
|
||
|
C = {};
|
||
|
for (var _ in S) C[JSON.stringify(S[_])] = _;
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
5: [
|
||
|
function (t, e, i) {
|
||
|
var n = t(4),
|
||
|
a = function () {
|
||
|
return new u();
|
||
|
};
|
||
|
for (var o in n) {
|
||
|
a[o + "Raw"] = (function (t) {
|
||
|
return function (e) {
|
||
|
return (
|
||
|
"number" == typeof e &&
|
||
|
(e = Array.prototype.slice.call(arguments)),
|
||
|
n[t](e)
|
||
|
);
|
||
|
};
|
||
|
})(o);
|
||
|
var r = /(\w+)2(\w+)/.exec(o),
|
||
|
s = r[1],
|
||
|
l = r[2];
|
||
|
(a[s] = a[s] || {})[l] = a[o] = (function (t) {
|
||
|
return function (e) {
|
||
|
"number" == typeof e &&
|
||
|
(e = Array.prototype.slice.call(arguments));
|
||
|
var i = n[t](e);
|
||
|
if ("string" == typeof i || void 0 === i) return i;
|
||
|
for (var a = 0; a < i.length; a++) i[a] = Math.round(i[a]);
|
||
|
return i;
|
||
|
};
|
||
|
})(o);
|
||
|
}
|
||
|
var u = function () {
|
||
|
this.convs = {};
|
||
|
};
|
||
|
(u.prototype.routeSpace = function (t, e) {
|
||
|
var i = e[0];
|
||
|
return void 0 === i
|
||
|
? this.getValues(t)
|
||
|
: ("number" == typeof i && (i = Array.prototype.slice.call(e)),
|
||
|
this.setValues(t, i));
|
||
|
}),
|
||
|
(u.prototype.setValues = function (t, e) {
|
||
|
return (
|
||
|
(this.space = t), (this.convs = {}), (this.convs[t] = e), this
|
||
|
);
|
||
|
}),
|
||
|
(u.prototype.getValues = function (t) {
|
||
|
var e = this.convs[t];
|
||
|
if (!e) {
|
||
|
var i = this.space,
|
||
|
n = this.convs[i];
|
||
|
(e = a[i][t](n)), (this.convs[t] = e);
|
||
|
}
|
||
|
return e;
|
||
|
}),
|
||
|
["rgb", "hsl", "hsv", "cmyk", "keyword"].forEach(function (t) {
|
||
|
u.prototype[t] = function (e) {
|
||
|
return this.routeSpace(t, arguments);
|
||
|
};
|
||
|
}),
|
||
|
(e.exports = a);
|
||
|
},
|
||
|
{ 4: 4 },
|
||
|
],
|
||
|
6: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = {
|
||
|
aliceblue: [240, 248, 255],
|
||
|
antiquewhite: [250, 235, 215],
|
||
|
aqua: [0, 255, 255],
|
||
|
aquamarine: [127, 255, 212],
|
||
|
azure: [240, 255, 255],
|
||
|
beige: [245, 245, 220],
|
||
|
bisque: [255, 228, 196],
|
||
|
black: [0, 0, 0],
|
||
|
blanchedalmond: [255, 235, 205],
|
||
|
blue: [0, 0, 255],
|
||
|
blueviolet: [138, 43, 226],
|
||
|
brown: [165, 42, 42],
|
||
|
burlywood: [222, 184, 135],
|
||
|
cadetblue: [95, 158, 160],
|
||
|
chartreuse: [127, 255, 0],
|
||
|
chocolate: [210, 105, 30],
|
||
|
coral: [255, 127, 80],
|
||
|
cornflowerblue: [100, 149, 237],
|
||
|
cornsilk: [255, 248, 220],
|
||
|
crimson: [220, 20, 60],
|
||
|
cyan: [0, 255, 255],
|
||
|
darkblue: [0, 0, 139],
|
||
|
darkcyan: [0, 139, 139],
|
||
|
darkgoldenrod: [184, 134, 11],
|
||
|
darkgray: [169, 169, 169],
|
||
|
darkgreen: [0, 100, 0],
|
||
|
darkgrey: [169, 169, 169],
|
||
|
darkkhaki: [189, 183, 107],
|
||
|
darkmagenta: [139, 0, 139],
|
||
|
darkolivegreen: [85, 107, 47],
|
||
|
darkorange: [255, 140, 0],
|
||
|
darkorchid: [153, 50, 204],
|
||
|
darkred: [139, 0, 0],
|
||
|
darksalmon: [233, 150, 122],
|
||
|
darkseagreen: [143, 188, 143],
|
||
|
darkslateblue: [72, 61, 139],
|
||
|
darkslategray: [47, 79, 79],
|
||
|
darkslategrey: [47, 79, 79],
|
||
|
darkturquoise: [0, 206, 209],
|
||
|
darkviolet: [148, 0, 211],
|
||
|
deeppink: [255, 20, 147],
|
||
|
deepskyblue: [0, 191, 255],
|
||
|
dimgray: [105, 105, 105],
|
||
|
dimgrey: [105, 105, 105],
|
||
|
dodgerblue: [30, 144, 255],
|
||
|
firebrick: [178, 34, 34],
|
||
|
floralwhite: [255, 250, 240],
|
||
|
forestgreen: [34, 139, 34],
|
||
|
fuchsia: [255, 0, 255],
|
||
|
gainsboro: [220, 220, 220],
|
||
|
ghostwhite: [248, 248, 255],
|
||
|
gold: [255, 215, 0],
|
||
|
goldenrod: [218, 165, 32],
|
||
|
gray: [128, 128, 128],
|
||
|
green: [0, 128, 0],
|
||
|
greenyellow: [173, 255, 47],
|
||
|
grey: [128, 128, 128],
|
||
|
honeydew: [240, 255, 240],
|
||
|
hotpink: [255, 105, 180],
|
||
|
indianred: [205, 92, 92],
|
||
|
indigo: [75, 0, 130],
|
||
|
ivory: [255, 255, 240],
|
||
|
khaki: [240, 230, 140],
|
||
|
lavender: [230, 230, 250],
|
||
|
lavenderblush: [255, 240, 245],
|
||
|
lawngreen: [124, 252, 0],
|
||
|
lemonchiffon: [255, 250, 205],
|
||
|
lightblue: [173, 216, 230],
|
||
|
lightcoral: [240, 128, 128],
|
||
|
lightcyan: [224, 255, 255],
|
||
|
lightgoldenrodyellow: [250, 250, 210],
|
||
|
lightgray: [211, 211, 211],
|
||
|
lightgreen: [144, 238, 144],
|
||
|
lightgrey: [211, 211, 211],
|
||
|
lightpink: [255, 182, 193],
|
||
|
lightsalmon: [255, 160, 122],
|
||
|
lightseagreen: [32, 178, 170],
|
||
|
lightskyblue: [135, 206, 250],
|
||
|
lightslategray: [119, 136, 153],
|
||
|
lightslategrey: [119, 136, 153],
|
||
|
lightsteelblue: [176, 196, 222],
|
||
|
lightyellow: [255, 255, 224],
|
||
|
lime: [0, 255, 0],
|
||
|
limegreen: [50, 205, 50],
|
||
|
linen: [250, 240, 230],
|
||
|
magenta: [255, 0, 255],
|
||
|
maroon: [128, 0, 0],
|
||
|
mediumaquamarine: [102, 205, 170],
|
||
|
mediumblue: [0, 0, 205],
|
||
|
mediumorchid: [186, 85, 211],
|
||
|
mediumpurple: [147, 112, 219],
|
||
|
mediumseagreen: [60, 179, 113],
|
||
|
mediumslateblue: [123, 104, 238],
|
||
|
mediumspringgreen: [0, 250, 154],
|
||
|
mediumturquoise: [72, 209, 204],
|
||
|
mediumvioletred: [199, 21, 133],
|
||
|
midnightblue: [25, 25, 112],
|
||
|
mintcream: [245, 255, 250],
|
||
|
mistyrose: [255, 228, 225],
|
||
|
moccasin: [255, 228, 181],
|
||
|
navajowhite: [255, 222, 173],
|
||
|
navy: [0, 0, 128],
|
||
|
oldlace: [253, 245, 230],
|
||
|
olive: [128, 128, 0],
|
||
|
olivedrab: [107, 142, 35],
|
||
|
orange: [255, 165, 0],
|
||
|
orangered: [255, 69, 0],
|
||
|
orchid: [218, 112, 214],
|
||
|
palegoldenrod: [238, 232, 170],
|
||
|
palegreen: [152, 251, 152],
|
||
|
paleturquoise: [175, 238, 238],
|
||
|
palevioletred: [219, 112, 147],
|
||
|
papayawhip: [255, 239, 213],
|
||
|
peachpuff: [255, 218, 185],
|
||
|
peru: [205, 133, 63],
|
||
|
pink: [255, 192, 203],
|
||
|
plum: [221, 160, 221],
|
||
|
powderblue: [176, 224, 230],
|
||
|
purple: [128, 0, 128],
|
||
|
rebeccapurple: [102, 51, 153],
|
||
|
red: [255, 0, 0],
|
||
|
rosybrown: [188, 143, 143],
|
||
|
royalblue: [65, 105, 225],
|
||
|
saddlebrown: [139, 69, 19],
|
||
|
salmon: [250, 128, 114],
|
||
|
sandybrown: [244, 164, 96],
|
||
|
seagreen: [46, 139, 87],
|
||
|
seashell: [255, 245, 238],
|
||
|
sienna: [160, 82, 45],
|
||
|
silver: [192, 192, 192],
|
||
|
skyblue: [135, 206, 235],
|
||
|
slateblue: [106, 90, 205],
|
||
|
slategray: [112, 128, 144],
|
||
|
slategrey: [112, 128, 144],
|
||
|
snow: [255, 250, 250],
|
||
|
springgreen: [0, 255, 127],
|
||
|
steelblue: [70, 130, 180],
|
||
|
tan: [210, 180, 140],
|
||
|
teal: [0, 128, 128],
|
||
|
thistle: [216, 191, 216],
|
||
|
tomato: [255, 99, 71],
|
||
|
turquoise: [64, 224, 208],
|
||
|
violet: [238, 130, 238],
|
||
|
wheat: [245, 222, 179],
|
||
|
white: [255, 255, 255],
|
||
|
whitesmoke: [245, 245, 245],
|
||
|
yellow: [255, 255, 0],
|
||
|
yellowgreen: [154, 205, 50],
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
7: [
|
||
|
function (t, e, i) {
|
||
|
var n = t(29)();
|
||
|
(n.helpers = t(45)),
|
||
|
t(27)(n),
|
||
|
(n.defaults = t(25)),
|
||
|
(n.Element = t(26)),
|
||
|
(n.elements = t(40)),
|
||
|
(n.Interaction = t(28)),
|
||
|
(n.layouts = t(30)),
|
||
|
(n.platform = t(48)),
|
||
|
(n.plugins = t(31)),
|
||
|
(n.Ticks = t(34)),
|
||
|
t(22)(n),
|
||
|
t(23)(n),
|
||
|
t(24)(n),
|
||
|
t(33)(n),
|
||
|
t(32)(n),
|
||
|
t(35)(n),
|
||
|
t(55)(n),
|
||
|
t(53)(n),
|
||
|
t(54)(n),
|
||
|
t(56)(n),
|
||
|
t(57)(n),
|
||
|
t(58)(n),
|
||
|
t(15)(n),
|
||
|
t(16)(n),
|
||
|
t(17)(n),
|
||
|
t(18)(n),
|
||
|
t(19)(n),
|
||
|
t(20)(n),
|
||
|
t(21)(n),
|
||
|
t(8)(n),
|
||
|
t(9)(n),
|
||
|
t(10)(n),
|
||
|
t(11)(n),
|
||
|
t(12)(n),
|
||
|
t(13)(n),
|
||
|
t(14)(n);
|
||
|
var a = t(49);
|
||
|
for (var o in a) a.hasOwnProperty(o) && n.plugins.register(a[o]);
|
||
|
n.platform.initialize(),
|
||
|
(e.exports = n),
|
||
|
"undefined" != typeof window && (window.Chart = n),
|
||
|
(n.Legend = a.legend._element),
|
||
|
(n.Title = a.title._element),
|
||
|
(n.pluginService = n.plugins),
|
||
|
(n.PluginBase = n.Element.extend({})),
|
||
|
(n.canvasHelpers = n.helpers.canvas),
|
||
|
(n.layoutService = n.layouts);
|
||
|
},
|
||
|
{
|
||
|
10: 10,
|
||
|
11: 11,
|
||
|
12: 12,
|
||
|
13: 13,
|
||
|
14: 14,
|
||
|
15: 15,
|
||
|
16: 16,
|
||
|
17: 17,
|
||
|
18: 18,
|
||
|
19: 19,
|
||
|
20: 20,
|
||
|
21: 21,
|
||
|
22: 22,
|
||
|
23: 23,
|
||
|
24: 24,
|
||
|
25: 25,
|
||
|
26: 26,
|
||
|
27: 27,
|
||
|
28: 28,
|
||
|
29: 29,
|
||
|
30: 30,
|
||
|
31: 31,
|
||
|
32: 32,
|
||
|
33: 33,
|
||
|
34: 34,
|
||
|
35: 35,
|
||
|
40: 40,
|
||
|
45: 45,
|
||
|
48: 48,
|
||
|
49: 49,
|
||
|
53: 53,
|
||
|
54: 54,
|
||
|
55: 55,
|
||
|
56: 56,
|
||
|
57: 57,
|
||
|
58: 58,
|
||
|
8: 8,
|
||
|
9: 9,
|
||
|
},
|
||
|
],
|
||
|
8: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = function (t) {
|
||
|
t.Bar = function (e, i) {
|
||
|
return (i.type = "bar"), new t(e, i);
|
||
|
};
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
9: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = function (t) {
|
||
|
t.Bubble = function (e, i) {
|
||
|
return (i.type = "bubble"), new t(e, i);
|
||
|
};
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
10: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = function (t) {
|
||
|
t.Doughnut = function (e, i) {
|
||
|
return (i.type = "doughnut"), new t(e, i);
|
||
|
};
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
11: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = function (t) {
|
||
|
t.Line = function (e, i) {
|
||
|
return (i.type = "line"), new t(e, i);
|
||
|
};
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
12: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = function (t) {
|
||
|
t.PolarArea = function (e, i) {
|
||
|
return (i.type = "polarArea"), new t(e, i);
|
||
|
};
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
13: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = function (t) {
|
||
|
t.Radar = function (e, i) {
|
||
|
return (i.type = "radar"), new t(e, i);
|
||
|
};
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
14: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = function (t) {
|
||
|
t.Scatter = function (e, i) {
|
||
|
return (i.type = "scatter"), new t(e, i);
|
||
|
};
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
15: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(40),
|
||
|
o = t(45);
|
||
|
n._set("bar", {
|
||
|
hover: { mode: "label" },
|
||
|
scales: {
|
||
|
xAxes: [
|
||
|
{
|
||
|
type: "category",
|
||
|
categoryPercentage: 0.8,
|
||
|
barPercentage: 0.9,
|
||
|
offset: !0,
|
||
|
gridLines: { offsetGridLines: !0 },
|
||
|
},
|
||
|
],
|
||
|
yAxes: [{ type: "linear" }],
|
||
|
},
|
||
|
}),
|
||
|
n._set("horizontalBar", {
|
||
|
hover: { mode: "index", axis: "y" },
|
||
|
scales: {
|
||
|
xAxes: [{ type: "linear", position: "bottom" }],
|
||
|
yAxes: [
|
||
|
{
|
||
|
position: "left",
|
||
|
type: "category",
|
||
|
categoryPercentage: 0.8,
|
||
|
barPercentage: 0.9,
|
||
|
offset: !0,
|
||
|
gridLines: { offsetGridLines: !0 },
|
||
|
},
|
||
|
],
|
||
|
},
|
||
|
elements: { rectangle: { borderSkipped: "left" } },
|
||
|
tooltips: {
|
||
|
callbacks: {
|
||
|
title: function (t, e) {
|
||
|
var i = "";
|
||
|
return (
|
||
|
t.length > 0 &&
|
||
|
(t[0].yLabel
|
||
|
? (i = t[0].yLabel)
|
||
|
: e.labels.length > 0 &&
|
||
|
t[0].index < e.labels.length &&
|
||
|
(i = e.labels[t[0].index])),
|
||
|
i
|
||
|
);
|
||
|
},
|
||
|
label: function (t, e) {
|
||
|
return (
|
||
|
(e.datasets[t.datasetIndex].label || "") + ": " + t.xLabel
|
||
|
);
|
||
|
},
|
||
|
},
|
||
|
mode: "index",
|
||
|
axis: "y",
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
(t.controllers.bar = t.DatasetController.extend({
|
||
|
dataElementType: a.Rectangle,
|
||
|
initialize: function () {
|
||
|
var e;
|
||
|
t.DatasetController.prototype.initialize.apply(
|
||
|
this,
|
||
|
arguments
|
||
|
),
|
||
|
((e = this.getMeta()).stack = this.getDataset().stack),
|
||
|
(e.bar = !0);
|
||
|
},
|
||
|
update: function (t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n = this.getMeta().data;
|
||
|
for (
|
||
|
this._ruler = this.getRuler(), e = 0, i = n.length;
|
||
|
e < i;
|
||
|
++e
|
||
|
)
|
||
|
this.updateElement(n[e], e, t);
|
||
|
},
|
||
|
updateElement: function (t, e, i) {
|
||
|
var n = this,
|
||
|
a = n.chart,
|
||
|
r = n.getMeta(),
|
||
|
s = n.getDataset(),
|
||
|
l = t.custom || {},
|
||
|
u = a.options.elements.rectangle;
|
||
|
(t._xScale = n.getScaleForId(r.xAxisID)),
|
||
|
(t._yScale = n.getScaleForId(r.yAxisID)),
|
||
|
(t._datasetIndex = n.index),
|
||
|
(t._index = e),
|
||
|
(t._model = {
|
||
|
datasetLabel: s.label,
|
||
|
label: a.data.labels[e],
|
||
|
borderSkipped: l.borderSkipped
|
||
|
? l.borderSkipped
|
||
|
: u.borderSkipped,
|
||
|
backgroundColor: l.backgroundColor
|
||
|
? l.backgroundColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
s.backgroundColor,
|
||
|
e,
|
||
|
u.backgroundColor
|
||
|
),
|
||
|
borderColor: l.borderColor
|
||
|
? l.borderColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
s.borderColor,
|
||
|
e,
|
||
|
u.borderColor
|
||
|
),
|
||
|
borderWidth: l.borderWidth
|
||
|
? l.borderWidth
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
s.borderWidth,
|
||
|
e,
|
||
|
u.borderWidth
|
||
|
),
|
||
|
}),
|
||
|
n.updateElementGeometry(t, e, i),
|
||
|
t.pivot();
|
||
|
},
|
||
|
updateElementGeometry: function (t, e, i) {
|
||
|
var n = this,
|
||
|
a = t._model,
|
||
|
o = n.getValueScale(),
|
||
|
r = o.getBasePixel(),
|
||
|
s = o.isHorizontal(),
|
||
|
l = n._ruler || n.getRuler(),
|
||
|
u = n.calculateBarValuePixels(n.index, e),
|
||
|
d = n.calculateBarIndexPixels(n.index, e, l);
|
||
|
(a.horizontal = s),
|
||
|
(a.base = i ? r : u.base),
|
||
|
(a.x = s ? (i ? r : u.head) : d.center),
|
||
|
(a.y = s ? d.center : i ? r : u.head),
|
||
|
(a.height = s ? d.size : void 0),
|
||
|
(a.width = s ? void 0 : d.size);
|
||
|
},
|
||
|
getValueScaleId: function () {
|
||
|
return this.getMeta().yAxisID;
|
||
|
},
|
||
|
getIndexScaleId: function () {
|
||
|
return this.getMeta().xAxisID;
|
||
|
},
|
||
|
getValueScale: function () {
|
||
|
return this.getScaleForId(this.getValueScaleId());
|
||
|
},
|
||
|
getIndexScale: function () {
|
||
|
return this.getScaleForId(this.getIndexScaleId());
|
||
|
},
|
||
|
_getStacks: function (t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n = this.chart,
|
||
|
a = this.getIndexScale().options.stacked,
|
||
|
o = void 0 === t ? n.data.datasets.length : t + 1,
|
||
|
r = [];
|
||
|
for (e = 0; e < o; ++e)
|
||
|
(i = n.getDatasetMeta(e)).bar &&
|
||
|
n.isDatasetVisible(e) &&
|
||
|
(!1 === a ||
|
||
|
(!0 === a && -1 === r.indexOf(i.stack)) ||
|
||
|
(void 0 === a &&
|
||
|
(void 0 === i.stack || -1 === r.indexOf(i.stack)))) &&
|
||
|
r.push(i.stack);
|
||
|
return r;
|
||
|
},
|
||
|
getStackCount: function () {
|
||
|
return this._getStacks().length;
|
||
|
},
|
||
|
getStackIndex: function (t, e) {
|
||
|
var i = this._getStacks(t),
|
||
|
n = void 0 !== e ? i.indexOf(e) : -1;
|
||
|
return -1 === n ? i.length - 1 : n;
|
||
|
},
|
||
|
getRuler: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i = this.getIndexScale(),
|
||
|
n = this.getStackCount(),
|
||
|
a = this.index,
|
||
|
r = i.isHorizontal(),
|
||
|
s = r ? i.left : i.top,
|
||
|
l = s + (r ? i.width : i.height),
|
||
|
u = [];
|
||
|
for (t = 0, e = this.getMeta().data.length; t < e; ++t)
|
||
|
u.push(i.getPixelForValue(null, t, a));
|
||
|
return {
|
||
|
min: o.isNullOrUndef(i.options.barThickness)
|
||
|
? (function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
o,
|
||
|
r = t.isHorizontal() ? t.width : t.height,
|
||
|
s = t.getTicks();
|
||
|
for (a = 1, o = e.length; a < o; ++a)
|
||
|
r = Math.min(r, e[a] - e[a - 1]);
|
||
|
for (a = 0, o = s.length; a < o; ++a)
|
||
|
(n = t.getPixelForTick(a)),
|
||
|
(r = a > 0 ? Math.min(r, n - i) : r),
|
||
|
(i = n);
|
||
|
return r;
|
||
|
})(i, u)
|
||
|
: -1,
|
||
|
pixels: u,
|
||
|
start: s,
|
||
|
end: l,
|
||
|
stackCount: n,
|
||
|
scale: i,
|
||
|
};
|
||
|
},
|
||
|
calculateBarValuePixels: function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s,
|
||
|
l = this.chart,
|
||
|
u = this.getMeta(),
|
||
|
d = this.getValueScale(),
|
||
|
c = l.data.datasets,
|
||
|
h = d.getRightValue(c[t].data[e]),
|
||
|
f = d.options.stacked,
|
||
|
g = u.stack,
|
||
|
p = 0;
|
||
|
if (f || (void 0 === f && void 0 !== g))
|
||
|
for (i = 0; i < t; ++i)
|
||
|
(n = l.getDatasetMeta(i)).bar &&
|
||
|
n.stack === g &&
|
||
|
n.controller.getValueScaleId() === d.id &&
|
||
|
l.isDatasetVisible(i) &&
|
||
|
((a = d.getRightValue(c[i].data[e])),
|
||
|
((h < 0 && a < 0) || (h >= 0 && a > 0)) && (p += a));
|
||
|
return (
|
||
|
(o = d.getPixelForValue(p)),
|
||
|
{
|
||
|
size: (s = ((r = d.getPixelForValue(p + h)) - o) / 2),
|
||
|
base: o,
|
||
|
head: r,
|
||
|
center: r + s / 2,
|
||
|
}
|
||
|
);
|
||
|
},
|
||
|
calculateBarIndexPixels: function (t, e, i) {
|
||
|
var n,
|
||
|
a,
|
||
|
r,
|
||
|
s,
|
||
|
l,
|
||
|
u,
|
||
|
d,
|
||
|
c,
|
||
|
h,
|
||
|
f,
|
||
|
g,
|
||
|
p,
|
||
|
m,
|
||
|
v,
|
||
|
b,
|
||
|
x,
|
||
|
y,
|
||
|
k = i.scale.options,
|
||
|
M =
|
||
|
"flex" === k.barThickness
|
||
|
? ((h = e),
|
||
|
(g = k),
|
||
|
(m = (f = i).pixels),
|
||
|
(v = m[h]),
|
||
|
(b = h > 0 ? m[h - 1] : null),
|
||
|
(x = h < m.length - 1 ? m[h + 1] : null),
|
||
|
(y = g.categoryPercentage),
|
||
|
null === b &&
|
||
|
(b = v - (null === x ? f.end - v : x - v)),
|
||
|
null === x && (x = v + v - b),
|
||
|
(p = v - ((v - b) / 2) * y),
|
||
|
{
|
||
|
chunk: (((x - b) / 2) * y) / f.stackCount,
|
||
|
ratio: g.barPercentage,
|
||
|
start: p,
|
||
|
})
|
||
|
: ((n = e),
|
||
|
(a = i),
|
||
|
(u = (r = k).barThickness),
|
||
|
(d = a.stackCount),
|
||
|
(c = a.pixels[n]),
|
||
|
o.isNullOrUndef(u)
|
||
|
? ((s = a.min * r.categoryPercentage),
|
||
|
(l = r.barPercentage))
|
||
|
: ((s = u * d), (l = 1)),
|
||
|
{ chunk: s / d, ratio: l, start: c - s / 2 }),
|
||
|
w = this.getStackIndex(t, this.getMeta().stack),
|
||
|
S = M.start + M.chunk * w + M.chunk / 2,
|
||
|
C = Math.min(
|
||
|
o.valueOrDefault(k.maxBarThickness, 1 / 0),
|
||
|
M.chunk * M.ratio
|
||
|
);
|
||
|
return {
|
||
|
base: S - C / 2,
|
||
|
head: S + C / 2,
|
||
|
center: S,
|
||
|
size: C,
|
||
|
};
|
||
|
},
|
||
|
draw: function () {
|
||
|
var t = this.chart,
|
||
|
e = this.getValueScale(),
|
||
|
i = this.getMeta().data,
|
||
|
n = this.getDataset(),
|
||
|
a = i.length,
|
||
|
r = 0;
|
||
|
for (o.canvas.clipArea(t.ctx, t.chartArea); r < a; ++r)
|
||
|
isNaN(e.getRightValue(n.data[r])) || i[r].draw();
|
||
|
o.canvas.unclipArea(t.ctx);
|
||
|
},
|
||
|
setHoverStyle: function (t) {
|
||
|
var e = this.chart.data.datasets[t._datasetIndex],
|
||
|
i = t._index,
|
||
|
n = t.custom || {},
|
||
|
a = t._model;
|
||
|
(a.backgroundColor = n.hoverBackgroundColor
|
||
|
? n.hoverBackgroundColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.hoverBackgroundColor,
|
||
|
i,
|
||
|
o.getHoverColor(a.backgroundColor)
|
||
|
)),
|
||
|
(a.borderColor = n.hoverBorderColor
|
||
|
? n.hoverBorderColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.hoverBorderColor,
|
||
|
i,
|
||
|
o.getHoverColor(a.borderColor)
|
||
|
)),
|
||
|
(a.borderWidth = n.hoverBorderWidth
|
||
|
? n.hoverBorderWidth
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.hoverBorderWidth,
|
||
|
i,
|
||
|
a.borderWidth
|
||
|
));
|
||
|
},
|
||
|
removeHoverStyle: function (t) {
|
||
|
var e = this.chart.data.datasets[t._datasetIndex],
|
||
|
i = t._index,
|
||
|
n = t.custom || {},
|
||
|
a = t._model,
|
||
|
r = this.chart.options.elements.rectangle;
|
||
|
(a.backgroundColor = n.backgroundColor
|
||
|
? n.backgroundColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.backgroundColor,
|
||
|
i,
|
||
|
r.backgroundColor
|
||
|
)),
|
||
|
(a.borderColor = n.borderColor
|
||
|
? n.borderColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.borderColor,
|
||
|
i,
|
||
|
r.borderColor
|
||
|
)),
|
||
|
(a.borderWidth = n.borderWidth
|
||
|
? n.borderWidth
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.borderWidth,
|
||
|
i,
|
||
|
r.borderWidth
|
||
|
));
|
||
|
},
|
||
|
})),
|
||
|
(t.controllers.horizontalBar = t.controllers.bar.extend({
|
||
|
getValueScaleId: function () {
|
||
|
return this.getMeta().xAxisID;
|
||
|
},
|
||
|
getIndexScaleId: function () {
|
||
|
return this.getMeta().yAxisID;
|
||
|
},
|
||
|
}));
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 40: 40, 45: 45 },
|
||
|
],
|
||
|
16: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(40),
|
||
|
o = t(45);
|
||
|
n._set("bubble", {
|
||
|
hover: { mode: "single" },
|
||
|
scales: {
|
||
|
xAxes: [{ type: "linear", position: "bottom", id: "x-axis-0" }],
|
||
|
yAxes: [{ type: "linear", position: "left", id: "y-axis-0" }],
|
||
|
},
|
||
|
tooltips: {
|
||
|
callbacks: {
|
||
|
title: function () {
|
||
|
return "";
|
||
|
},
|
||
|
label: function (t, e) {
|
||
|
var i = e.datasets[t.datasetIndex].label || "",
|
||
|
n = e.datasets[t.datasetIndex].data[t.index];
|
||
|
return (
|
||
|
i + ": (" + t.xLabel + ", " + t.yLabel + ", " + n.r + ")"
|
||
|
);
|
||
|
},
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
t.controllers.bubble = t.DatasetController.extend({
|
||
|
dataElementType: a.Point,
|
||
|
update: function (t) {
|
||
|
var e = this,
|
||
|
i = e.getMeta().data;
|
||
|
o.each(i, function (i, n) {
|
||
|
e.updateElement(i, n, t);
|
||
|
});
|
||
|
},
|
||
|
updateElement: function (t, e, i) {
|
||
|
var n = this,
|
||
|
a = n.getMeta(),
|
||
|
o = t.custom || {},
|
||
|
r = n.getScaleForId(a.xAxisID),
|
||
|
s = n.getScaleForId(a.yAxisID),
|
||
|
l = n._resolveElementOptions(t, e),
|
||
|
u = n.getDataset().data[e],
|
||
|
d = n.index,
|
||
|
c = i
|
||
|
? r.getPixelForDecimal(0.5)
|
||
|
: r.getPixelForValue(
|
||
|
"object" == typeof u ? u : NaN,
|
||
|
e,
|
||
|
d
|
||
|
),
|
||
|
h = i ? s.getBasePixel() : s.getPixelForValue(u, e, d);
|
||
|
(t._xScale = r),
|
||
|
(t._yScale = s),
|
||
|
(t._options = l),
|
||
|
(t._datasetIndex = d),
|
||
|
(t._index = e),
|
||
|
(t._model = {
|
||
|
backgroundColor: l.backgroundColor,
|
||
|
borderColor: l.borderColor,
|
||
|
borderWidth: l.borderWidth,
|
||
|
hitRadius: l.hitRadius,
|
||
|
pointStyle: l.pointStyle,
|
||
|
radius: i ? 0 : l.radius,
|
||
|
skip: o.skip || isNaN(c) || isNaN(h),
|
||
|
x: c,
|
||
|
y: h,
|
||
|
}),
|
||
|
t.pivot();
|
||
|
},
|
||
|
setHoverStyle: function (t) {
|
||
|
var e = t._model,
|
||
|
i = t._options;
|
||
|
(e.backgroundColor = o.valueOrDefault(
|
||
|
i.hoverBackgroundColor,
|
||
|
o.getHoverColor(i.backgroundColor)
|
||
|
)),
|
||
|
(e.borderColor = o.valueOrDefault(
|
||
|
i.hoverBorderColor,
|
||
|
o.getHoverColor(i.borderColor)
|
||
|
)),
|
||
|
(e.borderWidth = o.valueOrDefault(
|
||
|
i.hoverBorderWidth,
|
||
|
i.borderWidth
|
||
|
)),
|
||
|
(e.radius = i.radius + i.hoverRadius);
|
||
|
},
|
||
|
removeHoverStyle: function (t) {
|
||
|
var e = t._model,
|
||
|
i = t._options;
|
||
|
(e.backgroundColor = i.backgroundColor),
|
||
|
(e.borderColor = i.borderColor),
|
||
|
(e.borderWidth = i.borderWidth),
|
||
|
(e.radius = i.radius);
|
||
|
},
|
||
|
_resolveElementOptions: function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
r = this.chart,
|
||
|
s = r.data.datasets[this.index],
|
||
|
l = t.custom || {},
|
||
|
u = r.options.elements.point,
|
||
|
d = o.options.resolve,
|
||
|
c = s.data[e],
|
||
|
h = {},
|
||
|
f = {
|
||
|
chart: r,
|
||
|
dataIndex: e,
|
||
|
dataset: s,
|
||
|
datasetIndex: this.index,
|
||
|
},
|
||
|
g = [
|
||
|
"backgroundColor",
|
||
|
"borderColor",
|
||
|
"borderWidth",
|
||
|
"hoverBackgroundColor",
|
||
|
"hoverBorderColor",
|
||
|
"hoverBorderWidth",
|
||
|
"hoverRadius",
|
||
|
"hitRadius",
|
||
|
"pointStyle",
|
||
|
];
|
||
|
for (i = 0, n = g.length; i < n; ++i)
|
||
|
h[(a = g[i])] = d([l[a], s[a], u[a]], f, e);
|
||
|
return (
|
||
|
(h.radius = d(
|
||
|
[l.radius, c ? c.r : void 0, s.radius, u.radius],
|
||
|
f,
|
||
|
e
|
||
|
)),
|
||
|
h
|
||
|
);
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 40: 40, 45: 45 },
|
||
|
],
|
||
|
17: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(40),
|
||
|
o = t(45);
|
||
|
n._set("doughnut", {
|
||
|
animation: { animateRotate: !0, animateScale: !1 },
|
||
|
hover: { mode: "single" },
|
||
|
legendCallback: function (t) {
|
||
|
var e = [];
|
||
|
e.push('<ul class="' + t.id + '-legend">');
|
||
|
var i = t.data,
|
||
|
n = i.datasets,
|
||
|
a = i.labels;
|
||
|
if (n.length)
|
||
|
for (var o = 0; o < n[0].data.length; ++o)
|
||
|
e.push(
|
||
|
'<li><span style="background-color:' +
|
||
|
n[0].backgroundColor[o] +
|
||
|
'"></span>'
|
||
|
),
|
||
|
a[o] && e.push(a[o]),
|
||
|
e.push("</li>");
|
||
|
return e.push("</ul>"), e.join("");
|
||
|
},
|
||
|
legend: {
|
||
|
labels: {
|
||
|
generateLabels: function (t) {
|
||
|
var e = t.data;
|
||
|
return e.labels.length && e.datasets.length
|
||
|
? e.labels.map(function (i, n) {
|
||
|
var a = t.getDatasetMeta(0),
|
||
|
r = e.datasets[0],
|
||
|
s = a.data[n],
|
||
|
l = (s && s.custom) || {},
|
||
|
u = o.valueAtIndexOrDefault,
|
||
|
d = t.options.elements.arc;
|
||
|
return {
|
||
|
text: i,
|
||
|
fillStyle: l.backgroundColor
|
||
|
? l.backgroundColor
|
||
|
: u(r.backgroundColor, n, d.backgroundColor),
|
||
|
strokeStyle: l.borderColor
|
||
|
? l.borderColor
|
||
|
: u(r.borderColor, n, d.borderColor),
|
||
|
lineWidth: l.borderWidth
|
||
|
? l.borderWidth
|
||
|
: u(r.borderWidth, n, d.borderWidth),
|
||
|
hidden: isNaN(r.data[n]) || a.data[n].hidden,
|
||
|
index: n,
|
||
|
};
|
||
|
})
|
||
|
: [];
|
||
|
},
|
||
|
},
|
||
|
onClick: function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
o = e.index,
|
||
|
r = this.chart;
|
||
|
for (i = 0, n = (r.data.datasets || []).length; i < n; ++i)
|
||
|
(a = r.getDatasetMeta(i)).data[o] &&
|
||
|
(a.data[o].hidden = !a.data[o].hidden);
|
||
|
r.update();
|
||
|
},
|
||
|
},
|
||
|
cutoutPercentage: 50,
|
||
|
rotation: -0.5 * Math.PI,
|
||
|
circumference: 2 * Math.PI,
|
||
|
tooltips: {
|
||
|
callbacks: {
|
||
|
title: function () {
|
||
|
return "";
|
||
|
},
|
||
|
label: function (t, e) {
|
||
|
var i = e.labels[t.index],
|
||
|
n = ": " + e.datasets[t.datasetIndex].data[t.index];
|
||
|
return o.isArray(i) ? ((i = i.slice())[0] += n) : (i += n), i;
|
||
|
},
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
n._set("pie", o.clone(n.doughnut)),
|
||
|
n._set("pie", { cutoutPercentage: 0 }),
|
||
|
(e.exports = function (t) {
|
||
|
t.controllers.doughnut = t.controllers.pie =
|
||
|
t.DatasetController.extend({
|
||
|
dataElementType: a.Arc,
|
||
|
linkScales: o.noop,
|
||
|
getRingIndex: function (t) {
|
||
|
for (var e = 0, i = 0; i < t; ++i)
|
||
|
this.chart.isDatasetVisible(i) && ++e;
|
||
|
return e;
|
||
|
},
|
||
|
update: function (t) {
|
||
|
var e = this,
|
||
|
i = e.chart,
|
||
|
n = i.chartArea,
|
||
|
a = i.options,
|
||
|
r = a.elements.arc,
|
||
|
s = n.right - n.left - r.borderWidth,
|
||
|
l = n.bottom - n.top - r.borderWidth,
|
||
|
u = Math.min(s, l),
|
||
|
d = { x: 0, y: 0 },
|
||
|
c = e.getMeta(),
|
||
|
h = a.cutoutPercentage,
|
||
|
f = a.circumference;
|
||
|
if (f < 2 * Math.PI) {
|
||
|
var g = a.rotation % (2 * Math.PI),
|
||
|
p =
|
||
|
(g +=
|
||
|
2 *
|
||
|
Math.PI *
|
||
|
(g >= Math.PI ? -1 : g < -Math.PI ? 1 : 0)) + f,
|
||
|
m = Math.cos(g),
|
||
|
v = Math.sin(g),
|
||
|
b = Math.cos(p),
|
||
|
x = Math.sin(p),
|
||
|
y =
|
||
|
(g <= 0 && p >= 0) ||
|
||
|
(g <= 2 * Math.PI && 2 * Math.PI <= p),
|
||
|
k =
|
||
|
(g <= 0.5 * Math.PI && 0.5 * Math.PI <= p) ||
|
||
|
(g <= 2.5 * Math.PI && 2.5 * Math.PI <= p),
|
||
|
M =
|
||
|
(g <= -Math.PI && -Math.PI <= p) ||
|
||
|
(g <= Math.PI && Math.PI <= p),
|
||
|
w =
|
||
|
(g <= 0.5 * -Math.PI && 0.5 * -Math.PI <= p) ||
|
||
|
(g <= 1.5 * Math.PI && 1.5 * Math.PI <= p),
|
||
|
S = h / 100,
|
||
|
C = M
|
||
|
? -1
|
||
|
: Math.min(m * (m < 0 ? 1 : S), b * (b < 0 ? 1 : S)),
|
||
|
_ = w
|
||
|
? -1
|
||
|
: Math.min(v * (v < 0 ? 1 : S), x * (x < 0 ? 1 : S)),
|
||
|
D = y
|
||
|
? 1
|
||
|
: Math.max(m * (m > 0 ? 1 : S), b * (b > 0 ? 1 : S)),
|
||
|
I = k
|
||
|
? 1
|
||
|
: Math.max(v * (v > 0 ? 1 : S), x * (x > 0 ? 1 : S)),
|
||
|
P = 0.5 * (D - C),
|
||
|
A = 0.5 * (I - _);
|
||
|
(u = Math.min(s / P, l / A)),
|
||
|
(d = { x: -0.5 * (D + C), y: -0.5 * (I + _) });
|
||
|
}
|
||
|
(i.borderWidth = e.getMaxBorderWidth(c.data)),
|
||
|
(i.outerRadius = Math.max((u - i.borderWidth) / 2, 0)),
|
||
|
(i.innerRadius = Math.max(
|
||
|
h ? (i.outerRadius / 100) * h : 0,
|
||
|
0
|
||
|
)),
|
||
|
(i.radiusLength =
|
||
|
(i.outerRadius - i.innerRadius) /
|
||
|
i.getVisibleDatasetCount()),
|
||
|
(i.offsetX = d.x * i.outerRadius),
|
||
|
(i.offsetY = d.y * i.outerRadius),
|
||
|
(c.total = e.calculateTotal()),
|
||
|
(e.outerRadius =
|
||
|
i.outerRadius -
|
||
|
i.radiusLength * e.getRingIndex(e.index)),
|
||
|
(e.innerRadius = Math.max(
|
||
|
e.outerRadius - i.radiusLength,
|
||
|
0
|
||
|
)),
|
||
|
o.each(c.data, function (i, n) {
|
||
|
e.updateElement(i, n, t);
|
||
|
});
|
||
|
},
|
||
|
updateElement: function (t, e, i) {
|
||
|
var n = this,
|
||
|
a = n.chart,
|
||
|
r = a.chartArea,
|
||
|
s = a.options,
|
||
|
l = s.animation,
|
||
|
u = (r.left + r.right) / 2,
|
||
|
d = (r.top + r.bottom) / 2,
|
||
|
c = s.rotation,
|
||
|
h = s.rotation,
|
||
|
f = n.getDataset(),
|
||
|
g =
|
||
|
i && l.animateRotate
|
||
|
? 0
|
||
|
: t.hidden
|
||
|
? 0
|
||
|
: n.calculateCircumference(f.data[e]) *
|
||
|
(s.circumference / (2 * Math.PI)),
|
||
|
p = i && l.animateScale ? 0 : n.innerRadius,
|
||
|
m = i && l.animateScale ? 0 : n.outerRadius,
|
||
|
v = o.valueAtIndexOrDefault;
|
||
|
o.extend(t, {
|
||
|
_datasetIndex: n.index,
|
||
|
_index: e,
|
||
|
_model: {
|
||
|
x: u + a.offsetX,
|
||
|
y: d + a.offsetY,
|
||
|
startAngle: c,
|
||
|
endAngle: h,
|
||
|
circumference: g,
|
||
|
outerRadius: m,
|
||
|
innerRadius: p,
|
||
|
label: v(f.label, e, a.data.labels[e]),
|
||
|
},
|
||
|
});
|
||
|
var b = t._model;
|
||
|
this.removeHoverStyle(t),
|
||
|
(i && l.animateRotate) ||
|
||
|
((b.startAngle =
|
||
|
0 === e
|
||
|
? s.rotation
|
||
|
: n.getMeta().data[e - 1]._model.endAngle),
|
||
|
(b.endAngle = b.startAngle + b.circumference)),
|
||
|
t.pivot();
|
||
|
},
|
||
|
removeHoverStyle: function (e) {
|
||
|
t.DatasetController.prototype.removeHoverStyle.call(
|
||
|
this,
|
||
|
e,
|
||
|
this.chart.options.elements.arc
|
||
|
);
|
||
|
},
|
||
|
calculateTotal: function () {
|
||
|
var t,
|
||
|
e = this.getDataset(),
|
||
|
i = this.getMeta(),
|
||
|
n = 0;
|
||
|
return (
|
||
|
o.each(i.data, function (i, a) {
|
||
|
(t = e.data[a]),
|
||
|
isNaN(t) || i.hidden || (n += Math.abs(t));
|
||
|
}),
|
||
|
n
|
||
|
);
|
||
|
},
|
||
|
calculateCircumference: function (t) {
|
||
|
var e = this.getMeta().total;
|
||
|
return e > 0 && !isNaN(t)
|
||
|
? 2 * Math.PI * (Math.abs(t) / e)
|
||
|
: 0;
|
||
|
},
|
||
|
getMaxBorderWidth: function (t) {
|
||
|
for (
|
||
|
var e, i, n = 0, a = this.index, o = t.length, r = 0;
|
||
|
r < o;
|
||
|
r++
|
||
|
)
|
||
|
(e = t[r]._model ? t[r]._model.borderWidth : 0),
|
||
|
(n =
|
||
|
(i = t[r]._chart
|
||
|
? t[r]._chart.config.data.datasets[a]
|
||
|
.hoverBorderWidth
|
||
|
: 0) > (n = e > n ? e : n)
|
||
|
? i
|
||
|
: n);
|
||
|
return n;
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 40: 40, 45: 45 },
|
||
|
],
|
||
|
18: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(40),
|
||
|
o = t(45);
|
||
|
n._set("line", {
|
||
|
showLines: !0,
|
||
|
spanGaps: !1,
|
||
|
hover: { mode: "label" },
|
||
|
scales: {
|
||
|
xAxes: [{ type: "category", id: "x-axis-0" }],
|
||
|
yAxes: [{ type: "linear", id: "y-axis-0" }],
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
function e(t, e) {
|
||
|
return o.valueOrDefault(t.showLine, e.showLines);
|
||
|
}
|
||
|
t.controllers.line = t.DatasetController.extend({
|
||
|
datasetElementType: a.Line,
|
||
|
dataElementType: a.Point,
|
||
|
update: function (t) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
r = this,
|
||
|
s = r.getMeta(),
|
||
|
l = s.dataset,
|
||
|
u = s.data || [],
|
||
|
d = r.chart.options,
|
||
|
c = d.elements.line,
|
||
|
h = r.getScaleForId(s.yAxisID),
|
||
|
f = r.getDataset(),
|
||
|
g = e(f, d);
|
||
|
for (
|
||
|
g &&
|
||
|
((a = l.custom || {}),
|
||
|
void 0 !== f.tension &&
|
||
|
void 0 === f.lineTension &&
|
||
|
(f.lineTension = f.tension),
|
||
|
(l._scale = h),
|
||
|
(l._datasetIndex = r.index),
|
||
|
(l._children = u),
|
||
|
(l._model = {
|
||
|
spanGaps: f.spanGaps ? f.spanGaps : d.spanGaps,
|
||
|
tension: a.tension
|
||
|
? a.tension
|
||
|
: o.valueOrDefault(f.lineTension, c.tension),
|
||
|
backgroundColor: a.backgroundColor
|
||
|
? a.backgroundColor
|
||
|
: f.backgroundColor || c.backgroundColor,
|
||
|
borderWidth: a.borderWidth
|
||
|
? a.borderWidth
|
||
|
: f.borderWidth || c.borderWidth,
|
||
|
borderColor: a.borderColor
|
||
|
? a.borderColor
|
||
|
: f.borderColor || c.borderColor,
|
||
|
borderCapStyle: a.borderCapStyle
|
||
|
? a.borderCapStyle
|
||
|
: f.borderCapStyle || c.borderCapStyle,
|
||
|
borderDash: a.borderDash
|
||
|
? a.borderDash
|
||
|
: f.borderDash || c.borderDash,
|
||
|
borderDashOffset: a.borderDashOffset
|
||
|
? a.borderDashOffset
|
||
|
: f.borderDashOffset || c.borderDashOffset,
|
||
|
borderJoinStyle: a.borderJoinStyle
|
||
|
? a.borderJoinStyle
|
||
|
: f.borderJoinStyle || c.borderJoinStyle,
|
||
|
fill: a.fill
|
||
|
? a.fill
|
||
|
: void 0 !== f.fill
|
||
|
? f.fill
|
||
|
: c.fill,
|
||
|
steppedLine: a.steppedLine
|
||
|
? a.steppedLine
|
||
|
: o.valueOrDefault(f.steppedLine, c.stepped),
|
||
|
cubicInterpolationMode: a.cubicInterpolationMode
|
||
|
? a.cubicInterpolationMode
|
||
|
: o.valueOrDefault(
|
||
|
f.cubicInterpolationMode,
|
||
|
c.cubicInterpolationMode
|
||
|
),
|
||
|
}),
|
||
|
l.pivot()),
|
||
|
i = 0,
|
||
|
n = u.length;
|
||
|
i < n;
|
||
|
++i
|
||
|
)
|
||
|
r.updateElement(u[i], i, t);
|
||
|
for (
|
||
|
g &&
|
||
|
0 !== l._model.tension &&
|
||
|
r.updateBezierControlPoints(),
|
||
|
i = 0,
|
||
|
n = u.length;
|
||
|
i < n;
|
||
|
++i
|
||
|
)
|
||
|
u[i].pivot();
|
||
|
},
|
||
|
getPointBackgroundColor: function (t, e) {
|
||
|
var i = this.chart.options.elements.point.backgroundColor,
|
||
|
n = this.getDataset(),
|
||
|
a = t.custom || {};
|
||
|
return (
|
||
|
a.backgroundColor
|
||
|
? (i = a.backgroundColor)
|
||
|
: n.pointBackgroundColor
|
||
|
? (i = o.valueAtIndexOrDefault(
|
||
|
n.pointBackgroundColor,
|
||
|
e,
|
||
|
i
|
||
|
))
|
||
|
: n.backgroundColor && (i = n.backgroundColor),
|
||
|
i
|
||
|
);
|
||
|
},
|
||
|
getPointBorderColor: function (t, e) {
|
||
|
var i = this.chart.options.elements.point.borderColor,
|
||
|
n = this.getDataset(),
|
||
|
a = t.custom || {};
|
||
|
return (
|
||
|
a.borderColor
|
||
|
? (i = a.borderColor)
|
||
|
: n.pointBorderColor
|
||
|
? (i = o.valueAtIndexOrDefault(n.pointBorderColor, e, i))
|
||
|
: n.borderColor && (i = n.borderColor),
|
||
|
i
|
||
|
);
|
||
|
},
|
||
|
getPointBorderWidth: function (t, e) {
|
||
|
var i = this.chart.options.elements.point.borderWidth,
|
||
|
n = this.getDataset(),
|
||
|
a = t.custom || {};
|
||
|
return (
|
||
|
isNaN(a.borderWidth)
|
||
|
? !isNaN(n.pointBorderWidth) ||
|
||
|
o.isArray(n.pointBorderWidth)
|
||
|
? (i = o.valueAtIndexOrDefault(
|
||
|
n.pointBorderWidth,
|
||
|
e,
|
||
|
i
|
||
|
))
|
||
|
: isNaN(n.borderWidth) || (i = n.borderWidth)
|
||
|
: (i = a.borderWidth),
|
||
|
i
|
||
|
);
|
||
|
},
|
||
|
updateElement: function (t, e, i) {
|
||
|
var n,
|
||
|
a,
|
||
|
r = this,
|
||
|
s = r.getMeta(),
|
||
|
l = t.custom || {},
|
||
|
u = r.getDataset(),
|
||
|
d = r.index,
|
||
|
c = u.data[e],
|
||
|
h = r.getScaleForId(s.yAxisID),
|
||
|
f = r.getScaleForId(s.xAxisID),
|
||
|
g = r.chart.options.elements.point;
|
||
|
void 0 !== u.radius &&
|
||
|
void 0 === u.pointRadius &&
|
||
|
(u.pointRadius = u.radius),
|
||
|
void 0 !== u.hitRadius &&
|
||
|
void 0 === u.pointHitRadius &&
|
||
|
(u.pointHitRadius = u.hitRadius),
|
||
|
(n = f.getPixelForValue(
|
||
|
"object" == typeof c ? c : NaN,
|
||
|
e,
|
||
|
d
|
||
|
)),
|
||
|
(a = i ? h.getBasePixel() : r.calculatePointY(c, e, d)),
|
||
|
(t._xScale = f),
|
||
|
(t._yScale = h),
|
||
|
(t._datasetIndex = d),
|
||
|
(t._index = e),
|
||
|
(t._model = {
|
||
|
x: n,
|
||
|
y: a,
|
||
|
skip: l.skip || isNaN(n) || isNaN(a),
|
||
|
radius:
|
||
|
l.radius ||
|
||
|
o.valueAtIndexOrDefault(u.pointRadius, e, g.radius),
|
||
|
pointStyle:
|
||
|
l.pointStyle ||
|
||
|
o.valueAtIndexOrDefault(u.pointStyle, e, g.pointStyle),
|
||
|
backgroundColor: r.getPointBackgroundColor(t, e),
|
||
|
borderColor: r.getPointBorderColor(t, e),
|
||
|
borderWidth: r.getPointBorderWidth(t, e),
|
||
|
tension: s.dataset._model ? s.dataset._model.tension : 0,
|
||
|
steppedLine:
|
||
|
!!s.dataset._model && s.dataset._model.steppedLine,
|
||
|
hitRadius:
|
||
|
l.hitRadius ||
|
||
|
o.valueAtIndexOrDefault(
|
||
|
u.pointHitRadius,
|
||
|
e,
|
||
|
g.hitRadius
|
||
|
),
|
||
|
});
|
||
|
},
|
||
|
calculatePointY: function (t, e, i) {
|
||
|
var n,
|
||
|
a,
|
||
|
o,
|
||
|
r = this.chart,
|
||
|
s = this.getMeta(),
|
||
|
l = this.getScaleForId(s.yAxisID),
|
||
|
u = 0,
|
||
|
d = 0;
|
||
|
if (l.options.stacked) {
|
||
|
for (n = 0; n < i; n++)
|
||
|
if (
|
||
|
((a = r.data.datasets[n]),
|
||
|
"line" === (o = r.getDatasetMeta(n)).type &&
|
||
|
o.yAxisID === l.id &&
|
||
|
r.isDatasetVisible(n))
|
||
|
) {
|
||
|
var c = Number(l.getRightValue(a.data[e]));
|
||
|
c < 0 ? (d += c || 0) : (u += c || 0);
|
||
|
}
|
||
|
var h = Number(l.getRightValue(t));
|
||
|
return h < 0
|
||
|
? l.getPixelForValue(d + h)
|
||
|
: l.getPixelForValue(u + h);
|
||
|
}
|
||
|
return l.getPixelForValue(t);
|
||
|
},
|
||
|
updateBezierControlPoints: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i,
|
||
|
n,
|
||
|
a = this.getMeta(),
|
||
|
r = this.chart.chartArea,
|
||
|
s = a.data || [];
|
||
|
function l(t, e, i) {
|
||
|
return Math.max(Math.min(t, i), e);
|
||
|
}
|
||
|
if (
|
||
|
(a.dataset._model.spanGaps &&
|
||
|
(s = s.filter(function (t) {
|
||
|
return !t._model.skip;
|
||
|
})),
|
||
|
"monotone" === a.dataset._model.cubicInterpolationMode)
|
||
|
)
|
||
|
o.splineCurveMonotone(s);
|
||
|
else
|
||
|
for (t = 0, e = s.length; t < e; ++t)
|
||
|
(i = s[t]._model),
|
||
|
(n = o.splineCurve(
|
||
|
o.previousItem(s, t)._model,
|
||
|
i,
|
||
|
o.nextItem(s, t)._model,
|
||
|
a.dataset._model.tension
|
||
|
)),
|
||
|
(i.controlPointPreviousX = n.previous.x),
|
||
|
(i.controlPointPreviousY = n.previous.y),
|
||
|
(i.controlPointNextX = n.next.x),
|
||
|
(i.controlPointNextY = n.next.y);
|
||
|
if (this.chart.options.elements.line.capBezierPoints)
|
||
|
for (t = 0, e = s.length; t < e; ++t)
|
||
|
((i = s[t]._model).controlPointPreviousX = l(
|
||
|
i.controlPointPreviousX,
|
||
|
r.left,
|
||
|
r.right
|
||
|
)),
|
||
|
(i.controlPointPreviousY = l(
|
||
|
i.controlPointPreviousY,
|
||
|
r.top,
|
||
|
r.bottom
|
||
|
)),
|
||
|
(i.controlPointNextX = l(
|
||
|
i.controlPointNextX,
|
||
|
r.left,
|
||
|
r.right
|
||
|
)),
|
||
|
(i.controlPointNextY = l(
|
||
|
i.controlPointNextY,
|
||
|
r.top,
|
||
|
r.bottom
|
||
|
));
|
||
|
},
|
||
|
draw: function () {
|
||
|
var t = this.chart,
|
||
|
i = this.getMeta(),
|
||
|
n = i.data || [],
|
||
|
a = t.chartArea,
|
||
|
r = n.length,
|
||
|
s = 0;
|
||
|
for (
|
||
|
o.canvas.clipArea(t.ctx, a),
|
||
|
e(this.getDataset(), t.options) && i.dataset.draw(),
|
||
|
o.canvas.unclipArea(t.ctx);
|
||
|
s < r;
|
||
|
++s
|
||
|
)
|
||
|
n[s].draw(a);
|
||
|
},
|
||
|
setHoverStyle: function (t) {
|
||
|
var e = this.chart.data.datasets[t._datasetIndex],
|
||
|
i = t._index,
|
||
|
n = t.custom || {},
|
||
|
a = t._model;
|
||
|
(a.radius =
|
||
|
n.hoverRadius ||
|
||
|
o.valueAtIndexOrDefault(
|
||
|
e.pointHoverRadius,
|
||
|
i,
|
||
|
this.chart.options.elements.point.hoverRadius
|
||
|
)),
|
||
|
(a.backgroundColor =
|
||
|
n.hoverBackgroundColor ||
|
||
|
o.valueAtIndexOrDefault(
|
||
|
e.pointHoverBackgroundColor,
|
||
|
i,
|
||
|
o.getHoverColor(a.backgroundColor)
|
||
|
)),
|
||
|
(a.borderColor =
|
||
|
n.hoverBorderColor ||
|
||
|
o.valueAtIndexOrDefault(
|
||
|
e.pointHoverBorderColor,
|
||
|
i,
|
||
|
o.getHoverColor(a.borderColor)
|
||
|
)),
|
||
|
(a.borderWidth =
|
||
|
n.hoverBorderWidth ||
|
||
|
o.valueAtIndexOrDefault(
|
||
|
e.pointHoverBorderWidth,
|
||
|
i,
|
||
|
a.borderWidth
|
||
|
));
|
||
|
},
|
||
|
removeHoverStyle: function (t) {
|
||
|
var e = this,
|
||
|
i = e.chart.data.datasets[t._datasetIndex],
|
||
|
n = t._index,
|
||
|
a = t.custom || {},
|
||
|
r = t._model;
|
||
|
void 0 !== i.radius &&
|
||
|
void 0 === i.pointRadius &&
|
||
|
(i.pointRadius = i.radius),
|
||
|
(r.radius =
|
||
|
a.radius ||
|
||
|
o.valueAtIndexOrDefault(
|
||
|
i.pointRadius,
|
||
|
n,
|
||
|
e.chart.options.elements.point.radius
|
||
|
)),
|
||
|
(r.backgroundColor = e.getPointBackgroundColor(t, n)),
|
||
|
(r.borderColor = e.getPointBorderColor(t, n)),
|
||
|
(r.borderWidth = e.getPointBorderWidth(t, n));
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 40: 40, 45: 45 },
|
||
|
],
|
||
|
19: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(40),
|
||
|
o = t(45);
|
||
|
n._set("polarArea", {
|
||
|
scale: {
|
||
|
type: "radialLinear",
|
||
|
angleLines: { display: !1 },
|
||
|
gridLines: { circular: !0 },
|
||
|
pointLabels: { display: !1 },
|
||
|
ticks: { beginAtZero: !0 },
|
||
|
},
|
||
|
animation: { animateRotate: !0, animateScale: !0 },
|
||
|
startAngle: -0.5 * Math.PI,
|
||
|
legendCallback: function (t) {
|
||
|
var e = [];
|
||
|
e.push('<ul class="' + t.id + '-legend">');
|
||
|
var i = t.data,
|
||
|
n = i.datasets,
|
||
|
a = i.labels;
|
||
|
if (n.length)
|
||
|
for (var o = 0; o < n[0].data.length; ++o)
|
||
|
e.push(
|
||
|
'<li><span style="background-color:' +
|
||
|
n[0].backgroundColor[o] +
|
||
|
'"></span>'
|
||
|
),
|
||
|
a[o] && e.push(a[o]),
|
||
|
e.push("</li>");
|
||
|
return e.push("</ul>"), e.join("");
|
||
|
},
|
||
|
legend: {
|
||
|
labels: {
|
||
|
generateLabels: function (t) {
|
||
|
var e = t.data;
|
||
|
return e.labels.length && e.datasets.length
|
||
|
? e.labels.map(function (i, n) {
|
||
|
var a = t.getDatasetMeta(0),
|
||
|
r = e.datasets[0],
|
||
|
s = a.data[n].custom || {},
|
||
|
l = o.valueAtIndexOrDefault,
|
||
|
u = t.options.elements.arc;
|
||
|
return {
|
||
|
text: i,
|
||
|
fillStyle: s.backgroundColor
|
||
|
? s.backgroundColor
|
||
|
: l(r.backgroundColor, n, u.backgroundColor),
|
||
|
strokeStyle: s.borderColor
|
||
|
? s.borderColor
|
||
|
: l(r.borderColor, n, u.borderColor),
|
||
|
lineWidth: s.borderWidth
|
||
|
? s.borderWidth
|
||
|
: l(r.borderWidth, n, u.borderWidth),
|
||
|
hidden: isNaN(r.data[n]) || a.data[n].hidden,
|
||
|
index: n,
|
||
|
};
|
||
|
})
|
||
|
: [];
|
||
|
},
|
||
|
},
|
||
|
onClick: function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
o = e.index,
|
||
|
r = this.chart;
|
||
|
for (i = 0, n = (r.data.datasets || []).length; i < n; ++i)
|
||
|
(a = r.getDatasetMeta(i)).data[o].hidden = !a.data[o].hidden;
|
||
|
r.update();
|
||
|
},
|
||
|
},
|
||
|
tooltips: {
|
||
|
callbacks: {
|
||
|
title: function () {
|
||
|
return "";
|
||
|
},
|
||
|
label: function (t, e) {
|
||
|
return e.labels[t.index] + ": " + t.yLabel;
|
||
|
},
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
t.controllers.polarArea = t.DatasetController.extend({
|
||
|
dataElementType: a.Arc,
|
||
|
linkScales: o.noop,
|
||
|
update: function (t) {
|
||
|
var e = this,
|
||
|
i = e.chart,
|
||
|
n = i.chartArea,
|
||
|
a = e.getMeta(),
|
||
|
r = i.options,
|
||
|
s = r.elements.arc,
|
||
|
l = Math.min(n.right - n.left, n.bottom - n.top);
|
||
|
(i.outerRadius = Math.max((l - s.borderWidth / 2) / 2, 0)),
|
||
|
(i.innerRadius = Math.max(
|
||
|
r.cutoutPercentage
|
||
|
? (i.outerRadius / 100) * r.cutoutPercentage
|
||
|
: 1,
|
||
|
0
|
||
|
)),
|
||
|
(i.radiusLength =
|
||
|
(i.outerRadius - i.innerRadius) /
|
||
|
i.getVisibleDatasetCount()),
|
||
|
(e.outerRadius = i.outerRadius - i.radiusLength * e.index),
|
||
|
(e.innerRadius = e.outerRadius - i.radiusLength),
|
||
|
(a.count = e.countVisibleElements()),
|
||
|
o.each(a.data, function (i, n) {
|
||
|
e.updateElement(i, n, t);
|
||
|
});
|
||
|
},
|
||
|
updateElement: function (t, e, i) {
|
||
|
for (
|
||
|
var n = this,
|
||
|
a = n.chart,
|
||
|
r = n.getDataset(),
|
||
|
s = a.options,
|
||
|
l = s.animation,
|
||
|
u = a.scale,
|
||
|
d = a.data.labels,
|
||
|
c = n.calculateCircumference(r.data[e]),
|
||
|
h = u.xCenter,
|
||
|
f = u.yCenter,
|
||
|
g = 0,
|
||
|
p = n.getMeta(),
|
||
|
m = 0;
|
||
|
m < e;
|
||
|
++m
|
||
|
)
|
||
|
isNaN(r.data[m]) || p.data[m].hidden || ++g;
|
||
|
var v = s.startAngle,
|
||
|
b = t.hidden
|
||
|
? 0
|
||
|
: u.getDistanceFromCenterForValue(r.data[e]),
|
||
|
x = v + c * g,
|
||
|
y = x + (t.hidden ? 0 : c),
|
||
|
k = l.animateScale
|
||
|
? 0
|
||
|
: u.getDistanceFromCenterForValue(r.data[e]);
|
||
|
o.extend(t, {
|
||
|
_datasetIndex: n.index,
|
||
|
_index: e,
|
||
|
_scale: u,
|
||
|
_model: {
|
||
|
x: h,
|
||
|
y: f,
|
||
|
innerRadius: 0,
|
||
|
outerRadius: i ? k : b,
|
||
|
startAngle: i && l.animateRotate ? v : x,
|
||
|
endAngle: i && l.animateRotate ? v : y,
|
||
|
label: o.valueAtIndexOrDefault(d, e, d[e]),
|
||
|
},
|
||
|
}),
|
||
|
n.removeHoverStyle(t),
|
||
|
t.pivot();
|
||
|
},
|
||
|
removeHoverStyle: function (e) {
|
||
|
t.DatasetController.prototype.removeHoverStyle.call(
|
||
|
this,
|
||
|
e,
|
||
|
this.chart.options.elements.arc
|
||
|
);
|
||
|
},
|
||
|
countVisibleElements: function () {
|
||
|
var t = this.getDataset(),
|
||
|
e = this.getMeta(),
|
||
|
i = 0;
|
||
|
return (
|
||
|
o.each(e.data, function (e, n) {
|
||
|
isNaN(t.data[n]) || e.hidden || i++;
|
||
|
}),
|
||
|
i
|
||
|
);
|
||
|
},
|
||
|
calculateCircumference: function (t) {
|
||
|
var e = this.getMeta().count;
|
||
|
return e > 0 && !isNaN(t) ? (2 * Math.PI) / e : 0;
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 40: 40, 45: 45 },
|
||
|
],
|
||
|
20: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(40),
|
||
|
o = t(45);
|
||
|
n._set("radar", {
|
||
|
scale: { type: "radialLinear" },
|
||
|
elements: { line: { tension: 0 } },
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
t.controllers.radar = t.DatasetController.extend({
|
||
|
datasetElementType: a.Line,
|
||
|
dataElementType: a.Point,
|
||
|
linkScales: o.noop,
|
||
|
update: function (t) {
|
||
|
var e = this,
|
||
|
i = e.getMeta(),
|
||
|
n = i.dataset,
|
||
|
a = i.data,
|
||
|
r = n.custom || {},
|
||
|
s = e.getDataset(),
|
||
|
l = e.chart.options.elements.line,
|
||
|
u = e.chart.scale;
|
||
|
void 0 !== s.tension &&
|
||
|
void 0 === s.lineTension &&
|
||
|
(s.lineTension = s.tension),
|
||
|
o.extend(i.dataset, {
|
||
|
_datasetIndex: e.index,
|
||
|
_scale: u,
|
||
|
_children: a,
|
||
|
_loop: !0,
|
||
|
_model: {
|
||
|
tension: r.tension
|
||
|
? r.tension
|
||
|
: o.valueOrDefault(s.lineTension, l.tension),
|
||
|
backgroundColor: r.backgroundColor
|
||
|
? r.backgroundColor
|
||
|
: s.backgroundColor || l.backgroundColor,
|
||
|
borderWidth: r.borderWidth
|
||
|
? r.borderWidth
|
||
|
: s.borderWidth || l.borderWidth,
|
||
|
borderColor: r.borderColor
|
||
|
? r.borderColor
|
||
|
: s.borderColor || l.borderColor,
|
||
|
fill: r.fill
|
||
|
? r.fill
|
||
|
: void 0 !== s.fill
|
||
|
? s.fill
|
||
|
: l.fill,
|
||
|
borderCapStyle: r.borderCapStyle
|
||
|
? r.borderCapStyle
|
||
|
: s.borderCapStyle || l.borderCapStyle,
|
||
|
borderDash: r.borderDash
|
||
|
? r.borderDash
|
||
|
: s.borderDash || l.borderDash,
|
||
|
borderDashOffset: r.borderDashOffset
|
||
|
? r.borderDashOffset
|
||
|
: s.borderDashOffset || l.borderDashOffset,
|
||
|
borderJoinStyle: r.borderJoinStyle
|
||
|
? r.borderJoinStyle
|
||
|
: s.borderJoinStyle || l.borderJoinStyle,
|
||
|
},
|
||
|
}),
|
||
|
i.dataset.pivot(),
|
||
|
o.each(
|
||
|
a,
|
||
|
function (i, n) {
|
||
|
e.updateElement(i, n, t);
|
||
|
},
|
||
|
e
|
||
|
),
|
||
|
e.updateBezierControlPoints();
|
||
|
},
|
||
|
updateElement: function (t, e, i) {
|
||
|
var n = this,
|
||
|
a = t.custom || {},
|
||
|
r = n.getDataset(),
|
||
|
s = n.chart.scale,
|
||
|
l = n.chart.options.elements.point,
|
||
|
u = s.getPointPositionForValue(e, r.data[e]);
|
||
|
void 0 !== r.radius &&
|
||
|
void 0 === r.pointRadius &&
|
||
|
(r.pointRadius = r.radius),
|
||
|
void 0 !== r.hitRadius &&
|
||
|
void 0 === r.pointHitRadius &&
|
||
|
(r.pointHitRadius = r.hitRadius),
|
||
|
o.extend(t, {
|
||
|
_datasetIndex: n.index,
|
||
|
_index: e,
|
||
|
_scale: s,
|
||
|
_model: {
|
||
|
x: i ? s.xCenter : u.x,
|
||
|
y: i ? s.yCenter : u.y,
|
||
|
tension: a.tension
|
||
|
? a.tension
|
||
|
: o.valueOrDefault(
|
||
|
r.lineTension,
|
||
|
n.chart.options.elements.line.tension
|
||
|
),
|
||
|
radius: a.radius
|
||
|
? a.radius
|
||
|
: o.valueAtIndexOrDefault(r.pointRadius, e, l.radius),
|
||
|
backgroundColor: a.backgroundColor
|
||
|
? a.backgroundColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
r.pointBackgroundColor,
|
||
|
e,
|
||
|
l.backgroundColor
|
||
|
),
|
||
|
borderColor: a.borderColor
|
||
|
? a.borderColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
r.pointBorderColor,
|
||
|
e,
|
||
|
l.borderColor
|
||
|
),
|
||
|
borderWidth: a.borderWidth
|
||
|
? a.borderWidth
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
r.pointBorderWidth,
|
||
|
e,
|
||
|
l.borderWidth
|
||
|
),
|
||
|
pointStyle: a.pointStyle
|
||
|
? a.pointStyle
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
r.pointStyle,
|
||
|
e,
|
||
|
l.pointStyle
|
||
|
),
|
||
|
hitRadius: a.hitRadius
|
||
|
? a.hitRadius
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
r.pointHitRadius,
|
||
|
e,
|
||
|
l.hitRadius
|
||
|
),
|
||
|
},
|
||
|
}),
|
||
|
(t._model.skip = a.skip
|
||
|
? a.skip
|
||
|
: isNaN(t._model.x) || isNaN(t._model.y));
|
||
|
},
|
||
|
updateBezierControlPoints: function () {
|
||
|
var t = this.chart.chartArea,
|
||
|
e = this.getMeta();
|
||
|
o.each(e.data, function (i, n) {
|
||
|
var a = i._model,
|
||
|
r = o.splineCurve(
|
||
|
o.previousItem(e.data, n, !0)._model,
|
||
|
a,
|
||
|
o.nextItem(e.data, n, !0)._model,
|
||
|
a.tension
|
||
|
);
|
||
|
(a.controlPointPreviousX = Math.max(
|
||
|
Math.min(r.previous.x, t.right),
|
||
|
t.left
|
||
|
)),
|
||
|
(a.controlPointPreviousY = Math.max(
|
||
|
Math.min(r.previous.y, t.bottom),
|
||
|
t.top
|
||
|
)),
|
||
|
(a.controlPointNextX = Math.max(
|
||
|
Math.min(r.next.x, t.right),
|
||
|
t.left
|
||
|
)),
|
||
|
(a.controlPointNextY = Math.max(
|
||
|
Math.min(r.next.y, t.bottom),
|
||
|
t.top
|
||
|
)),
|
||
|
i.pivot();
|
||
|
});
|
||
|
},
|
||
|
setHoverStyle: function (t) {
|
||
|
var e = this.chart.data.datasets[t._datasetIndex],
|
||
|
i = t.custom || {},
|
||
|
n = t._index,
|
||
|
a = t._model;
|
||
|
(a.radius = i.hoverRadius
|
||
|
? i.hoverRadius
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.pointHoverRadius,
|
||
|
n,
|
||
|
this.chart.options.elements.point.hoverRadius
|
||
|
)),
|
||
|
(a.backgroundColor = i.hoverBackgroundColor
|
||
|
? i.hoverBackgroundColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.pointHoverBackgroundColor,
|
||
|
n,
|
||
|
o.getHoverColor(a.backgroundColor)
|
||
|
)),
|
||
|
(a.borderColor = i.hoverBorderColor
|
||
|
? i.hoverBorderColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.pointHoverBorderColor,
|
||
|
n,
|
||
|
o.getHoverColor(a.borderColor)
|
||
|
)),
|
||
|
(a.borderWidth = i.hoverBorderWidth
|
||
|
? i.hoverBorderWidth
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.pointHoverBorderWidth,
|
||
|
n,
|
||
|
a.borderWidth
|
||
|
));
|
||
|
},
|
||
|
removeHoverStyle: function (t) {
|
||
|
var e = this.chart.data.datasets[t._datasetIndex],
|
||
|
i = t.custom || {},
|
||
|
n = t._index,
|
||
|
a = t._model,
|
||
|
r = this.chart.options.elements.point;
|
||
|
(a.radius = i.radius
|
||
|
? i.radius
|
||
|
: o.valueAtIndexOrDefault(e.pointRadius, n, r.radius)),
|
||
|
(a.backgroundColor = i.backgroundColor
|
||
|
? i.backgroundColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.pointBackgroundColor,
|
||
|
n,
|
||
|
r.backgroundColor
|
||
|
)),
|
||
|
(a.borderColor = i.borderColor
|
||
|
? i.borderColor
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.pointBorderColor,
|
||
|
n,
|
||
|
r.borderColor
|
||
|
)),
|
||
|
(a.borderWidth = i.borderWidth
|
||
|
? i.borderWidth
|
||
|
: o.valueAtIndexOrDefault(
|
||
|
e.pointBorderWidth,
|
||
|
n,
|
||
|
r.borderWidth
|
||
|
));
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 40: 40, 45: 45 },
|
||
|
],
|
||
|
21: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
t(25)._set("scatter", {
|
||
|
hover: { mode: "single" },
|
||
|
scales: {
|
||
|
xAxes: [{ id: "x-axis-1", type: "linear", position: "bottom" }],
|
||
|
yAxes: [{ id: "y-axis-1", type: "linear", position: "left" }],
|
||
|
},
|
||
|
showLines: !1,
|
||
|
tooltips: {
|
||
|
callbacks: {
|
||
|
title: function () {
|
||
|
return "";
|
||
|
},
|
||
|
label: function (t) {
|
||
|
return "(" + t.xLabel + ", " + t.yLabel + ")";
|
||
|
},
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
t.controllers.scatter = t.controllers.line;
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25 },
|
||
|
],
|
||
|
22: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26),
|
||
|
o = t(45);
|
||
|
n._set("global", {
|
||
|
animation: {
|
||
|
duration: 1e3,
|
||
|
easing: "easeOutQuart",
|
||
|
onProgress: o.noop,
|
||
|
onComplete: o.noop,
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
(t.Animation = a.extend({
|
||
|
chart: null,
|
||
|
currentStep: 0,
|
||
|
numSteps: 60,
|
||
|
easing: "",
|
||
|
render: null,
|
||
|
onAnimationProgress: null,
|
||
|
onAnimationComplete: null,
|
||
|
})),
|
||
|
(t.animationService = {
|
||
|
frameDuration: 17,
|
||
|
animations: [],
|
||
|
dropFrames: 0,
|
||
|
request: null,
|
||
|
addAnimation: function (t, e, i, n) {
|
||
|
var a,
|
||
|
o,
|
||
|
r = this.animations;
|
||
|
for (
|
||
|
e.chart = t, n || (t.animating = !0), a = 0, o = r.length;
|
||
|
a < o;
|
||
|
++a
|
||
|
)
|
||
|
if (r[a].chart === t) return void (r[a] = e);
|
||
|
r.push(e), 1 === r.length && this.requestAnimationFrame();
|
||
|
},
|
||
|
cancelAnimation: function (t) {
|
||
|
var e = o.findIndex(this.animations, function (e) {
|
||
|
return e.chart === t;
|
||
|
});
|
||
|
-1 !== e &&
|
||
|
(this.animations.splice(e, 1), (t.animating = !1));
|
||
|
},
|
||
|
requestAnimationFrame: function () {
|
||
|
var t = this;
|
||
|
null === t.request &&
|
||
|
(t.request = o.requestAnimFrame.call(window, function () {
|
||
|
(t.request = null), t.startDigest();
|
||
|
}));
|
||
|
},
|
||
|
startDigest: function () {
|
||
|
var t = this,
|
||
|
e = Date.now(),
|
||
|
i = 0;
|
||
|
t.dropFrames > 1 &&
|
||
|
((i = Math.floor(t.dropFrames)),
|
||
|
(t.dropFrames = t.dropFrames % 1)),
|
||
|
t.advance(1 + i);
|
||
|
var n = Date.now();
|
||
|
(t.dropFrames += (n - e) / t.frameDuration),
|
||
|
t.animations.length > 0 && t.requestAnimationFrame();
|
||
|
},
|
||
|
advance: function (t) {
|
||
|
for (var e, i, n = this.animations, a = 0; a < n.length; )
|
||
|
(i = (e = n[a]).chart),
|
||
|
(e.currentStep = (e.currentStep || 0) + t),
|
||
|
(e.currentStep = Math.min(e.currentStep, e.numSteps)),
|
||
|
o.callback(e.render, [i, e], i),
|
||
|
o.callback(e.onAnimationProgress, [e], i),
|
||
|
e.currentStep >= e.numSteps
|
||
|
? (o.callback(e.onAnimationComplete, [e], i),
|
||
|
(i.animating = !1),
|
||
|
n.splice(a, 1))
|
||
|
: ++a;
|
||
|
},
|
||
|
}),
|
||
|
Object.defineProperty(
|
||
|
t.Animation.prototype,
|
||
|
"animationObject",
|
||
|
{
|
||
|
get: function () {
|
||
|
return this;
|
||
|
},
|
||
|
}
|
||
|
),
|
||
|
Object.defineProperty(t.Animation.prototype, "chartInstance", {
|
||
|
get: function () {
|
||
|
return this.chart;
|
||
|
},
|
||
|
set: function (t) {
|
||
|
this.chart = t;
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 26: 26, 45: 45 },
|
||
|
],
|
||
|
23: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(45),
|
||
|
o = t(28),
|
||
|
r = t(30),
|
||
|
s = t(48),
|
||
|
l = t(31);
|
||
|
e.exports = function (t) {
|
||
|
function e(t) {
|
||
|
return "top" === t || "bottom" === t;
|
||
|
}
|
||
|
(t.types = {}),
|
||
|
(t.instances = {}),
|
||
|
(t.controllers = {}),
|
||
|
a.extend(t.prototype, {
|
||
|
construct: function (e, i) {
|
||
|
var o,
|
||
|
r,
|
||
|
l = this;
|
||
|
((r = (o = (o = i) || {}).data = o.data || {}).datasets =
|
||
|
r.datasets || []),
|
||
|
(r.labels = r.labels || []),
|
||
|
(o.options = a.configMerge(
|
||
|
n.global,
|
||
|
n[o.type],
|
||
|
o.options || {}
|
||
|
)),
|
||
|
(i = o);
|
||
|
var u = s.acquireContext(e, i),
|
||
|
d = u && u.canvas,
|
||
|
c = d && d.height,
|
||
|
h = d && d.width;
|
||
|
(l.id = a.uid()),
|
||
|
(l.ctx = u),
|
||
|
(l.canvas = d),
|
||
|
(l.config = i),
|
||
|
(l.width = h),
|
||
|
(l.height = c),
|
||
|
(l.aspectRatio = c ? h / c : null),
|
||
|
(l.options = i.options),
|
||
|
(l._bufferedRender = !1),
|
||
|
(l.chart = l),
|
||
|
(l.controller = l),
|
||
|
(t.instances[l.id] = l),
|
||
|
Object.defineProperty(l, "data", {
|
||
|
get: function () {
|
||
|
return l.config.data;
|
||
|
},
|
||
|
set: function (t) {
|
||
|
l.config.data = t;
|
||
|
},
|
||
|
}),
|
||
|
u && d
|
||
|
? (l.initialize(), l.update())
|
||
|
: console.error(
|
||
|
"Failed to create chart: can't acquire context from the given item"
|
||
|
);
|
||
|
},
|
||
|
initialize: function () {
|
||
|
var t = this;
|
||
|
return (
|
||
|
l.notify(t, "beforeInit"),
|
||
|
a.retinaScale(t, t.options.devicePixelRatio),
|
||
|
t.bindEvents(),
|
||
|
t.options.responsive && t.resize(!0),
|
||
|
t.ensureScalesHaveIDs(),
|
||
|
t.buildOrUpdateScales(),
|
||
|
t.initToolTip(),
|
||
|
l.notify(t, "afterInit"),
|
||
|
t
|
||
|
);
|
||
|
},
|
||
|
clear: function () {
|
||
|
return a.canvas.clear(this), this;
|
||
|
},
|
||
|
stop: function () {
|
||
|
return t.animationService.cancelAnimation(this), this;
|
||
|
},
|
||
|
resize: function (t) {
|
||
|
var e = this,
|
||
|
i = e.options,
|
||
|
n = e.canvas,
|
||
|
o = (i.maintainAspectRatio && e.aspectRatio) || null,
|
||
|
r = Math.max(0, Math.floor(a.getMaximumWidth(n))),
|
||
|
s = Math.max(
|
||
|
0,
|
||
|
Math.floor(o ? r / o : a.getMaximumHeight(n))
|
||
|
);
|
||
|
if (
|
||
|
(e.width !== r || e.height !== s) &&
|
||
|
((n.width = e.width = r),
|
||
|
(n.height = e.height = s),
|
||
|
(n.style.width = r + "px"),
|
||
|
(n.style.height = s + "px"),
|
||
|
a.retinaScale(e, i.devicePixelRatio),
|
||
|
!t)
|
||
|
) {
|
||
|
var u = { width: r, height: s };
|
||
|
l.notify(e, "resize", [u]),
|
||
|
e.options.onResize && e.options.onResize(e, u),
|
||
|
e.stop(),
|
||
|
e.update(e.options.responsiveAnimationDuration);
|
||
|
}
|
||
|
},
|
||
|
ensureScalesHaveIDs: function () {
|
||
|
var t = this.options,
|
||
|
e = t.scales || {},
|
||
|
i = t.scale;
|
||
|
a.each(e.xAxes, function (t, e) {
|
||
|
t.id = t.id || "x-axis-" + e;
|
||
|
}),
|
||
|
a.each(e.yAxes, function (t, e) {
|
||
|
t.id = t.id || "y-axis-" + e;
|
||
|
}),
|
||
|
i && (i.id = i.id || "scale");
|
||
|
},
|
||
|
buildOrUpdateScales: function () {
|
||
|
var i = this,
|
||
|
n = i.options,
|
||
|
o = i.scales || {},
|
||
|
r = [],
|
||
|
s = Object.keys(o).reduce(function (t, e) {
|
||
|
return (t[e] = !1), t;
|
||
|
}, {});
|
||
|
n.scales &&
|
||
|
(r = r.concat(
|
||
|
(n.scales.xAxes || []).map(function (t) {
|
||
|
return {
|
||
|
options: t,
|
||
|
dtype: "category",
|
||
|
dposition: "bottom",
|
||
|
};
|
||
|
}),
|
||
|
(n.scales.yAxes || []).map(function (t) {
|
||
|
return {
|
||
|
options: t,
|
||
|
dtype: "linear",
|
||
|
dposition: "left",
|
||
|
};
|
||
|
})
|
||
|
)),
|
||
|
n.scale &&
|
||
|
r.push({
|
||
|
options: n.scale,
|
||
|
dtype: "radialLinear",
|
||
|
isDefault: !0,
|
||
|
dposition: "chartArea",
|
||
|
}),
|
||
|
a.each(r, function (n) {
|
||
|
var r = n.options,
|
||
|
l = r.id,
|
||
|
u = a.valueOrDefault(r.type, n.dtype);
|
||
|
e(r.position) !== e(n.dposition) &&
|
||
|
(r.position = n.dposition),
|
||
|
(s[l] = !0);
|
||
|
var d = null;
|
||
|
if (l in o && o[l].type === u)
|
||
|
((d = o[l]).options = r),
|
||
|
(d.ctx = i.ctx),
|
||
|
(d.chart = i);
|
||
|
else {
|
||
|
var c = t.scaleService.getScaleConstructor(u);
|
||
|
if (!c) return;
|
||
|
(d = new c({
|
||
|
id: l,
|
||
|
type: u,
|
||
|
options: r,
|
||
|
ctx: i.ctx,
|
||
|
chart: i,
|
||
|
})),
|
||
|
(o[d.id] = d);
|
||
|
}
|
||
|
d.mergeTicksOptions(), n.isDefault && (i.scale = d);
|
||
|
}),
|
||
|
a.each(s, function (t, e) {
|
||
|
t || delete o[e];
|
||
|
}),
|
||
|
(i.scales = o),
|
||
|
t.scaleService.addScalesToLayout(this);
|
||
|
},
|
||
|
buildOrUpdateControllers: function () {
|
||
|
var e = this,
|
||
|
i = [],
|
||
|
n = [];
|
||
|
return (
|
||
|
a.each(
|
||
|
e.data.datasets,
|
||
|
function (a, o) {
|
||
|
var r = e.getDatasetMeta(o),
|
||
|
s = a.type || e.config.type;
|
||
|
if (
|
||
|
(r.type &&
|
||
|
r.type !== s &&
|
||
|
(e.destroyDatasetMeta(o),
|
||
|
(r = e.getDatasetMeta(o))),
|
||
|
(r.type = s),
|
||
|
i.push(r.type),
|
||
|
r.controller)
|
||
|
)
|
||
|
r.controller.updateIndex(o),
|
||
|
r.controller.linkScales();
|
||
|
else {
|
||
|
var l = t.controllers[r.type];
|
||
|
if (void 0 === l)
|
||
|
throw new Error(
|
||
|
'"' + r.type + '" is not a chart type.'
|
||
|
);
|
||
|
(r.controller = new l(e, o)), n.push(r.controller);
|
||
|
}
|
||
|
},
|
||
|
e
|
||
|
),
|
||
|
n
|
||
|
);
|
||
|
},
|
||
|
resetElements: function () {
|
||
|
var t = this;
|
||
|
a.each(
|
||
|
t.data.datasets,
|
||
|
function (e, i) {
|
||
|
t.getDatasetMeta(i).controller.reset();
|
||
|
},
|
||
|
t
|
||
|
);
|
||
|
},
|
||
|
reset: function () {
|
||
|
this.resetElements(), this.tooltip.initialize();
|
||
|
},
|
||
|
update: function (e) {
|
||
|
var i,
|
||
|
n,
|
||
|
o = this;
|
||
|
if (
|
||
|
((e && "object" == typeof e) ||
|
||
|
(e = { duration: e, lazy: arguments[1] }),
|
||
|
(n = (i = o).options),
|
||
|
a.each(i.scales, function (t) {
|
||
|
r.removeBox(i, t);
|
||
|
}),
|
||
|
(n = a.configMerge(
|
||
|
t.defaults.global,
|
||
|
t.defaults[i.config.type],
|
||
|
n
|
||
|
)),
|
||
|
(i.options = i.config.options = n),
|
||
|
i.ensureScalesHaveIDs(),
|
||
|
i.buildOrUpdateScales(),
|
||
|
(i.tooltip._options = n.tooltips),
|
||
|
i.tooltip.initialize(),
|
||
|
l._invalidate(o),
|
||
|
!1 !== l.notify(o, "beforeUpdate"))
|
||
|
) {
|
||
|
o.tooltip._data = o.data;
|
||
|
var s = o.buildOrUpdateControllers();
|
||
|
a.each(
|
||
|
o.data.datasets,
|
||
|
function (t, e) {
|
||
|
o.getDatasetMeta(e).controller.buildOrUpdateElements();
|
||
|
},
|
||
|
o
|
||
|
),
|
||
|
o.updateLayout(),
|
||
|
o.options.animation &&
|
||
|
o.options.animation.duration &&
|
||
|
a.each(s, function (t) {
|
||
|
t.reset();
|
||
|
}),
|
||
|
o.updateDatasets(),
|
||
|
o.tooltip.initialize(),
|
||
|
(o.lastActive = []),
|
||
|
l.notify(o, "afterUpdate"),
|
||
|
o._bufferedRender
|
||
|
? (o._bufferedRequest = {
|
||
|
duration: e.duration,
|
||
|
easing: e.easing,
|
||
|
lazy: e.lazy,
|
||
|
})
|
||
|
: o.render(e);
|
||
|
}
|
||
|
},
|
||
|
updateLayout: function () {
|
||
|
!1 !== l.notify(this, "beforeLayout") &&
|
||
|
(r.update(this, this.width, this.height),
|
||
|
l.notify(this, "afterScaleUpdate"),
|
||
|
l.notify(this, "afterLayout"));
|
||
|
},
|
||
|
updateDatasets: function () {
|
||
|
if (!1 !== l.notify(this, "beforeDatasetsUpdate")) {
|
||
|
for (var t = 0, e = this.data.datasets.length; t < e; ++t)
|
||
|
this.updateDataset(t);
|
||
|
l.notify(this, "afterDatasetsUpdate");
|
||
|
}
|
||
|
},
|
||
|
updateDataset: function (t) {
|
||
|
var e = this.getDatasetMeta(t),
|
||
|
i = { meta: e, index: t };
|
||
|
!1 !== l.notify(this, "beforeDatasetUpdate", [i]) &&
|
||
|
(e.controller.update(),
|
||
|
l.notify(this, "afterDatasetUpdate", [i]));
|
||
|
},
|
||
|
render: function (e) {
|
||
|
var i = this;
|
||
|
(e && "object" == typeof e) ||
|
||
|
(e = { duration: e, lazy: arguments[1] });
|
||
|
var n = e.duration,
|
||
|
o = e.lazy;
|
||
|
if (!1 !== l.notify(i, "beforeRender")) {
|
||
|
var r = i.options.animation,
|
||
|
s = function (t) {
|
||
|
l.notify(i, "afterRender"),
|
||
|
a.callback(r && r.onComplete, [t], i);
|
||
|
};
|
||
|
if (
|
||
|
r &&
|
||
|
((void 0 !== n && 0 !== n) ||
|
||
|
(void 0 === n && 0 !== r.duration))
|
||
|
) {
|
||
|
var u = new t.Animation({
|
||
|
numSteps: (n || r.duration) / 16.66,
|
||
|
easing: e.easing || r.easing,
|
||
|
render: function (t, e) {
|
||
|
var i = a.easing.effects[e.easing],
|
||
|
n = e.currentStep,
|
||
|
o = n / e.numSteps;
|
||
|
t.draw(i(o), o, n);
|
||
|
},
|
||
|
onAnimationProgress: r.onProgress,
|
||
|
onAnimationComplete: s,
|
||
|
});
|
||
|
t.animationService.addAnimation(i, u, n, o);
|
||
|
} else
|
||
|
i.draw(), s(new t.Animation({ numSteps: 0, chart: i }));
|
||
|
return i;
|
||
|
}
|
||
|
},
|
||
|
draw: function (t) {
|
||
|
var e = this;
|
||
|
e.clear(),
|
||
|
a.isNullOrUndef(t) && (t = 1),
|
||
|
e.transition(t),
|
||
|
!1 !== l.notify(e, "beforeDraw", [t]) &&
|
||
|
(a.each(
|
||
|
e.boxes,
|
||
|
function (t) {
|
||
|
t.draw(e.chartArea);
|
||
|
},
|
||
|
e
|
||
|
),
|
||
|
e.scale && e.scale.draw(),
|
||
|
e.drawDatasets(t),
|
||
|
e._drawTooltip(t),
|
||
|
l.notify(e, "afterDraw", [t]));
|
||
|
},
|
||
|
transition: function (t) {
|
||
|
for (
|
||
|
var e = 0, i = (this.data.datasets || []).length;
|
||
|
e < i;
|
||
|
++e
|
||
|
)
|
||
|
this.isDatasetVisible(e) &&
|
||
|
this.getDatasetMeta(e).controller.transition(t);
|
||
|
this.tooltip.transition(t);
|
||
|
},
|
||
|
drawDatasets: function (t) {
|
||
|
var e = this;
|
||
|
if (!1 !== l.notify(e, "beforeDatasetsDraw", [t])) {
|
||
|
for (
|
||
|
var i = (e.data.datasets || []).length - 1;
|
||
|
i >= 0;
|
||
|
--i
|
||
|
)
|
||
|
e.isDatasetVisible(i) && e.drawDataset(i, t);
|
||
|
l.notify(e, "afterDatasetsDraw", [t]);
|
||
|
}
|
||
|
},
|
||
|
drawDataset: function (t, e) {
|
||
|
var i = this.getDatasetMeta(t),
|
||
|
n = { meta: i, index: t, easingValue: e };
|
||
|
!1 !== l.notify(this, "beforeDatasetDraw", [n]) &&
|
||
|
(i.controller.draw(e),
|
||
|
l.notify(this, "afterDatasetDraw", [n]));
|
||
|
},
|
||
|
_drawTooltip: function (t) {
|
||
|
var e = this.tooltip,
|
||
|
i = { tooltip: e, easingValue: t };
|
||
|
!1 !== l.notify(this, "beforeTooltipDraw", [i]) &&
|
||
|
(e.draw(), l.notify(this, "afterTooltipDraw", [i]));
|
||
|
},
|
||
|
getElementAtEvent: function (t) {
|
||
|
return o.modes.single(this, t);
|
||
|
},
|
||
|
getElementsAtEvent: function (t) {
|
||
|
return o.modes.label(this, t, { intersect: !0 });
|
||
|
},
|
||
|
getElementsAtXAxis: function (t) {
|
||
|
return o.modes["x-axis"](this, t, { intersect: !0 });
|
||
|
},
|
||
|
getElementsAtEventForMode: function (t, e, i) {
|
||
|
var n = o.modes[e];
|
||
|
return "function" == typeof n ? n(this, t, i) : [];
|
||
|
},
|
||
|
getDatasetAtEvent: function (t) {
|
||
|
return o.modes.dataset(this, t, { intersect: !0 });
|
||
|
},
|
||
|
getDatasetMeta: function (t) {
|
||
|
var e = this.data.datasets[t];
|
||
|
e._meta || (e._meta = {});
|
||
|
var i = e._meta[this.id];
|
||
|
return (
|
||
|
i ||
|
||
|
(i = e._meta[this.id] =
|
||
|
{
|
||
|
type: null,
|
||
|
data: [],
|
||
|
dataset: null,
|
||
|
controller: null,
|
||
|
hidden: null,
|
||
|
xAxisID: null,
|
||
|
yAxisID: null,
|
||
|
}),
|
||
|
i
|
||
|
);
|
||
|
},
|
||
|
getVisibleDatasetCount: function () {
|
||
|
for (
|
||
|
var t = 0, e = 0, i = this.data.datasets.length;
|
||
|
e < i;
|
||
|
++e
|
||
|
)
|
||
|
this.isDatasetVisible(e) && t++;
|
||
|
return t;
|
||
|
},
|
||
|
isDatasetVisible: function (t) {
|
||
|
var e = this.getDatasetMeta(t);
|
||
|
return "boolean" == typeof e.hidden
|
||
|
? !e.hidden
|
||
|
: !this.data.datasets[t].hidden;
|
||
|
},
|
||
|
generateLegend: function () {
|
||
|
return this.options.legendCallback(this);
|
||
|
},
|
||
|
destroyDatasetMeta: function (t) {
|
||
|
var e = this.id,
|
||
|
i = this.data.datasets[t],
|
||
|
n = i._meta && i._meta[e];
|
||
|
n && (n.controller.destroy(), delete i._meta[e]);
|
||
|
},
|
||
|
destroy: function () {
|
||
|
var e,
|
||
|
i,
|
||
|
n = this,
|
||
|
o = n.canvas;
|
||
|
for (n.stop(), e = 0, i = n.data.datasets.length; e < i; ++e)
|
||
|
n.destroyDatasetMeta(e);
|
||
|
o &&
|
||
|
(n.unbindEvents(),
|
||
|
a.canvas.clear(n),
|
||
|
s.releaseContext(n.ctx),
|
||
|
(n.canvas = null),
|
||
|
(n.ctx = null)),
|
||
|
l.notify(n, "destroy"),
|
||
|
delete t.instances[n.id];
|
||
|
},
|
||
|
toBase64Image: function () {
|
||
|
return this.canvas.toDataURL.apply(this.canvas, arguments);
|
||
|
},
|
||
|
initToolTip: function () {
|
||
|
var e = this;
|
||
|
e.tooltip = new t.Tooltip(
|
||
|
{
|
||
|
_chart: e,
|
||
|
_chartInstance: e,
|
||
|
_data: e.data,
|
||
|
_options: e.options.tooltips,
|
||
|
},
|
||
|
e
|
||
|
);
|
||
|
},
|
||
|
bindEvents: function () {
|
||
|
var t = this,
|
||
|
e = (t._listeners = {}),
|
||
|
i = function () {
|
||
|
t.eventHandler.apply(t, arguments);
|
||
|
};
|
||
|
a.each(t.options.events, function (n) {
|
||
|
s.addEventListener(t, n, i), (e[n] = i);
|
||
|
}),
|
||
|
t.options.responsive &&
|
||
|
((i = function () {
|
||
|
t.resize();
|
||
|
}),
|
||
|
s.addEventListener(t, "resize", i),
|
||
|
(e.resize = i));
|
||
|
},
|
||
|
unbindEvents: function () {
|
||
|
var t = this,
|
||
|
e = t._listeners;
|
||
|
e &&
|
||
|
(delete t._listeners,
|
||
|
a.each(e, function (e, i) {
|
||
|
s.removeEventListener(t, i, e);
|
||
|
}));
|
||
|
},
|
||
|
updateHoverStyle: function (t, e, i) {
|
||
|
var n,
|
||
|
a,
|
||
|
o,
|
||
|
r = i ? "setHoverStyle" : "removeHoverStyle";
|
||
|
for (a = 0, o = t.length; a < o; ++a)
|
||
|
(n = t[a]) &&
|
||
|
this.getDatasetMeta(n._datasetIndex).controller[r](n);
|
||
|
},
|
||
|
eventHandler: function (t) {
|
||
|
var e = this,
|
||
|
i = e.tooltip;
|
||
|
if (!1 !== l.notify(e, "beforeEvent", [t])) {
|
||
|
(e._bufferedRender = !0), (e._bufferedRequest = null);
|
||
|
var n = e.handleEvent(t);
|
||
|
i &&
|
||
|
(n = i._start ? i.handleEvent(t) : n | i.handleEvent(t)),
|
||
|
l.notify(e, "afterEvent", [t]);
|
||
|
var a = e._bufferedRequest;
|
||
|
return (
|
||
|
a
|
||
|
? e.render(a)
|
||
|
: n &&
|
||
|
!e.animating &&
|
||
|
(e.stop(),
|
||
|
e.render(e.options.hover.animationDuration, !0)),
|
||
|
(e._bufferedRender = !1),
|
||
|
(e._bufferedRequest = null),
|
||
|
e
|
||
|
);
|
||
|
}
|
||
|
},
|
||
|
handleEvent: function (t) {
|
||
|
var e,
|
||
|
i = this,
|
||
|
n = i.options || {},
|
||
|
o = n.hover;
|
||
|
return (
|
||
|
(i.lastActive = i.lastActive || []),
|
||
|
"mouseout" === t.type
|
||
|
? (i.active = [])
|
||
|
: (i.active = i.getElementsAtEventForMode(t, o.mode, o)),
|
||
|
a.callback(
|
||
|
n.onHover || n.hover.onHover,
|
||
|
[t.native, i.active],
|
||
|
i
|
||
|
),
|
||
|
("mouseup" !== t.type && "click" !== t.type) ||
|
||
|
(n.onClick && n.onClick.call(i, t.native, i.active)),
|
||
|
i.lastActive.length &&
|
||
|
i.updateHoverStyle(i.lastActive, o.mode, !1),
|
||
|
i.active.length &&
|
||
|
o.mode &&
|
||
|
i.updateHoverStyle(i.active, o.mode, !0),
|
||
|
(e = !a.arrayEquals(i.active, i.lastActive)),
|
||
|
(i.lastActive = i.active),
|
||
|
e
|
||
|
);
|
||
|
},
|
||
|
}),
|
||
|
(t.Controller = t);
|
||
|
};
|
||
|
},
|
||
|
{ 25: 25, 28: 28, 30: 30, 31: 31, 45: 45, 48: 48 },
|
||
|
],
|
||
|
24: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45);
|
||
|
e.exports = function (t) {
|
||
|
var e = ["push", "pop", "shift", "splice", "unshift"];
|
||
|
function i(t, i) {
|
||
|
var n = t._chartjs;
|
||
|
if (n) {
|
||
|
var a = n.listeners,
|
||
|
o = a.indexOf(i);
|
||
|
-1 !== o && a.splice(o, 1),
|
||
|
a.length > 0 ||
|
||
|
(e.forEach(function (e) {
|
||
|
delete t[e];
|
||
|
}),
|
||
|
delete t._chartjs);
|
||
|
}
|
||
|
}
|
||
|
(t.DatasetController = function (t, e) {
|
||
|
this.initialize(t, e);
|
||
|
}),
|
||
|
n.extend(t.DatasetController.prototype, {
|
||
|
datasetElementType: null,
|
||
|
dataElementType: null,
|
||
|
initialize: function (t, e) {
|
||
|
(this.chart = t),
|
||
|
(this.index = e),
|
||
|
this.linkScales(),
|
||
|
this.addElements();
|
||
|
},
|
||
|
updateIndex: function (t) {
|
||
|
this.index = t;
|
||
|
},
|
||
|
linkScales: function () {
|
||
|
var t = this,
|
||
|
e = t.getMeta(),
|
||
|
i = t.getDataset();
|
||
|
(null !== e.xAxisID && e.xAxisID in t.chart.scales) ||
|
||
|
(e.xAxisID =
|
||
|
i.xAxisID || t.chart.options.scales.xAxes[0].id),
|
||
|
(null !== e.yAxisID && e.yAxisID in t.chart.scales) ||
|
||
|
(e.yAxisID =
|
||
|
i.yAxisID || t.chart.options.scales.yAxes[0].id);
|
||
|
},
|
||
|
getDataset: function () {
|
||
|
return this.chart.data.datasets[this.index];
|
||
|
},
|
||
|
getMeta: function () {
|
||
|
return this.chart.getDatasetMeta(this.index);
|
||
|
},
|
||
|
getScaleForId: function (t) {
|
||
|
return this.chart.scales[t];
|
||
|
},
|
||
|
reset: function () {
|
||
|
this.update(!0);
|
||
|
},
|
||
|
destroy: function () {
|
||
|
this._data && i(this._data, this);
|
||
|
},
|
||
|
createMetaDataset: function () {
|
||
|
var t = this.datasetElementType;
|
||
|
return (
|
||
|
t &&
|
||
|
new t({ _chart: this.chart, _datasetIndex: this.index })
|
||
|
);
|
||
|
},
|
||
|
createMetaData: function (t) {
|
||
|
var e = this.dataElementType;
|
||
|
return (
|
||
|
e &&
|
||
|
new e({
|
||
|
_chart: this.chart,
|
||
|
_datasetIndex: this.index,
|
||
|
_index: t,
|
||
|
})
|
||
|
);
|
||
|
},
|
||
|
addElements: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i = this.getMeta(),
|
||
|
n = this.getDataset().data || [],
|
||
|
a = i.data;
|
||
|
for (t = 0, e = n.length; t < e; ++t)
|
||
|
a[t] = a[t] || this.createMetaData(t);
|
||
|
i.dataset = i.dataset || this.createMetaDataset();
|
||
|
},
|
||
|
addElementAndReset: function (t) {
|
||
|
var e = this.createMetaData(t);
|
||
|
this.getMeta().data.splice(t, 0, e),
|
||
|
this.updateElement(e, t, !0);
|
||
|
},
|
||
|
buildOrUpdateElements: function () {
|
||
|
var t,
|
||
|
a,
|
||
|
o = this,
|
||
|
r = o.getDataset(),
|
||
|
s = r.data || (r.data = []);
|
||
|
o._data !== s &&
|
||
|
(o._data && i(o._data, o),
|
||
|
(a = o),
|
||
|
(t = s)._chartjs
|
||
|
? t._chartjs.listeners.push(a)
|
||
|
: (Object.defineProperty(t, "_chartjs", {
|
||
|
configurable: !0,
|
||
|
enumerable: !1,
|
||
|
value: { listeners: [a] },
|
||
|
}),
|
||
|
e.forEach(function (e) {
|
||
|
var i =
|
||
|
"onData" + e.charAt(0).toUpperCase() + e.slice(1),
|
||
|
a = t[e];
|
||
|
Object.defineProperty(t, e, {
|
||
|
configurable: !0,
|
||
|
enumerable: !1,
|
||
|
value: function () {
|
||
|
var e = Array.prototype.slice.call(arguments),
|
||
|
o = a.apply(this, e);
|
||
|
return (
|
||
|
n.each(t._chartjs.listeners, function (t) {
|
||
|
"function" == typeof t[i] && t[i].apply(t, e);
|
||
|
}),
|
||
|
o
|
||
|
);
|
||
|
},
|
||
|
});
|
||
|
})),
|
||
|
(o._data = s)),
|
||
|
o.resyncElements();
|
||
|
},
|
||
|
update: n.noop,
|
||
|
transition: function (t) {
|
||
|
for (
|
||
|
var e = this.getMeta(),
|
||
|
i = e.data || [],
|
||
|
n = i.length,
|
||
|
a = 0;
|
||
|
a < n;
|
||
|
++a
|
||
|
)
|
||
|
i[a].transition(t);
|
||
|
e.dataset && e.dataset.transition(t);
|
||
|
},
|
||
|
draw: function () {
|
||
|
var t = this.getMeta(),
|
||
|
e = t.data || [],
|
||
|
i = e.length,
|
||
|
n = 0;
|
||
|
for (t.dataset && t.dataset.draw(); n < i; ++n) e[n].draw();
|
||
|
},
|
||
|
removeHoverStyle: function (t, e) {
|
||
|
var i = this.chart.data.datasets[t._datasetIndex],
|
||
|
a = t._index,
|
||
|
o = t.custom || {},
|
||
|
r = n.valueAtIndexOrDefault,
|
||
|
s = t._model;
|
||
|
(s.backgroundColor = o.backgroundColor
|
||
|
? o.backgroundColor
|
||
|
: r(i.backgroundColor, a, e.backgroundColor)),
|
||
|
(s.borderColor = o.borderColor
|
||
|
? o.borderColor
|
||
|
: r(i.borderColor, a, e.borderColor)),
|
||
|
(s.borderWidth = o.borderWidth
|
||
|
? o.borderWidth
|
||
|
: r(i.borderWidth, a, e.borderWidth));
|
||
|
},
|
||
|
setHoverStyle: function (t) {
|
||
|
var e = this.chart.data.datasets[t._datasetIndex],
|
||
|
i = t._index,
|
||
|
a = t.custom || {},
|
||
|
o = n.valueAtIndexOrDefault,
|
||
|
r = n.getHoverColor,
|
||
|
s = t._model;
|
||
|
(s.backgroundColor = a.hoverBackgroundColor
|
||
|
? a.hoverBackgroundColor
|
||
|
: o(e.hoverBackgroundColor, i, r(s.backgroundColor))),
|
||
|
(s.borderColor = a.hoverBorderColor
|
||
|
? a.hoverBorderColor
|
||
|
: o(e.hoverBorderColor, i, r(s.borderColor))),
|
||
|
(s.borderWidth = a.hoverBorderWidth
|
||
|
? a.hoverBorderWidth
|
||
|
: o(e.hoverBorderWidth, i, s.borderWidth));
|
||
|
},
|
||
|
resyncElements: function () {
|
||
|
var t = this.getMeta(),
|
||
|
e = this.getDataset().data,
|
||
|
i = t.data.length,
|
||
|
n = e.length;
|
||
|
n < i
|
||
|
? t.data.splice(n, i - n)
|
||
|
: n > i && this.insertElements(i, n - i);
|
||
|
},
|
||
|
insertElements: function (t, e) {
|
||
|
for (var i = 0; i < e; ++i) this.addElementAndReset(t + i);
|
||
|
},
|
||
|
onDataPush: function () {
|
||
|
this.insertElements(
|
||
|
this.getDataset().data.length - 1,
|
||
|
arguments.length
|
||
|
);
|
||
|
},
|
||
|
onDataPop: function () {
|
||
|
this.getMeta().data.pop();
|
||
|
},
|
||
|
onDataShift: function () {
|
||
|
this.getMeta().data.shift();
|
||
|
},
|
||
|
onDataSplice: function (t, e) {
|
||
|
this.getMeta().data.splice(t, e),
|
||
|
this.insertElements(t, arguments.length - 2);
|
||
|
},
|
||
|
onDataUnshift: function () {
|
||
|
this.insertElements(0, arguments.length);
|
||
|
},
|
||
|
}),
|
||
|
(t.DatasetController.extend = n.inherits);
|
||
|
};
|
||
|
},
|
||
|
{ 45: 45 },
|
||
|
],
|
||
|
25: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45);
|
||
|
e.exports = {
|
||
|
_set: function (t, e) {
|
||
|
return n.merge(this[t] || (this[t] = {}), e);
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{ 45: 45 },
|
||
|
],
|
||
|
26: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(3),
|
||
|
a = t(45);
|
||
|
var o = function (t) {
|
||
|
a.extend(this, t), this.initialize.apply(this, arguments);
|
||
|
};
|
||
|
a.extend(o.prototype, {
|
||
|
initialize: function () {
|
||
|
this.hidden = !1;
|
||
|
},
|
||
|
pivot: function () {
|
||
|
var t = this;
|
||
|
return (
|
||
|
t._view || (t._view = a.clone(t._model)), (t._start = {}), t
|
||
|
);
|
||
|
},
|
||
|
transition: function (t) {
|
||
|
var e = this,
|
||
|
i = e._model,
|
||
|
a = e._start,
|
||
|
o = e._view;
|
||
|
return i && 1 !== t
|
||
|
? (o || (o = e._view = {}),
|
||
|
a || (a = e._start = {}),
|
||
|
(function (t, e, i, a) {
|
||
|
var o,
|
||
|
r,
|
||
|
s,
|
||
|
l,
|
||
|
u,
|
||
|
d,
|
||
|
c,
|
||
|
h,
|
||
|
f,
|
||
|
g = Object.keys(i);
|
||
|
for (o = 0, r = g.length; o < r; ++o)
|
||
|
if (
|
||
|
((d = i[(s = g[o])]),
|
||
|
e.hasOwnProperty(s) || (e[s] = d),
|
||
|
(l = e[s]) !== d && "_" !== s[0])
|
||
|
) {
|
||
|
if (
|
||
|
(t.hasOwnProperty(s) || (t[s] = l),
|
||
|
(c = typeof d) == typeof (u = t[s]))
|
||
|
)
|
||
|
if ("string" === c) {
|
||
|
if ((h = n(u)).valid && (f = n(d)).valid) {
|
||
|
e[s] = f.mix(h, a).rgbString();
|
||
|
continue;
|
||
|
}
|
||
|
} else if (
|
||
|
"number" === c &&
|
||
|
isFinite(u) &&
|
||
|
isFinite(d)
|
||
|
) {
|
||
|
e[s] = u + (d - u) * a;
|
||
|
continue;
|
||
|
}
|
||
|
e[s] = d;
|
||
|
}
|
||
|
})(a, o, i, t),
|
||
|
e)
|
||
|
: ((e._view = i), (e._start = null), e);
|
||
|
},
|
||
|
tooltipPosition: function () {
|
||
|
return { x: this._model.x, y: this._model.y };
|
||
|
},
|
||
|
hasValue: function () {
|
||
|
return a.isNumber(this._model.x) && a.isNumber(this._model.y);
|
||
|
},
|
||
|
}),
|
||
|
(o.extend = a.inherits),
|
||
|
(e.exports = o);
|
||
|
},
|
||
|
{ 3: 3, 45: 45 },
|
||
|
],
|
||
|
27: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(3),
|
||
|
a = t(25),
|
||
|
o = t(45);
|
||
|
e.exports = function (t) {
|
||
|
function e(t, e, i) {
|
||
|
var n;
|
||
|
return (
|
||
|
"string" == typeof t
|
||
|
? ((n = parseInt(t, 10)),
|
||
|
-1 !== t.indexOf("%") && (n = (n / 100) * e.parentNode[i]))
|
||
|
: (n = t),
|
||
|
n
|
||
|
);
|
||
|
}
|
||
|
function i(t) {
|
||
|
return null != t && "none" !== t;
|
||
|
}
|
||
|
function r(t, n, a) {
|
||
|
var o = document.defaultView,
|
||
|
r = t.parentNode,
|
||
|
s = o.getComputedStyle(t)[n],
|
||
|
l = o.getComputedStyle(r)[n],
|
||
|
u = i(s),
|
||
|
d = i(l),
|
||
|
c = Number.POSITIVE_INFINITY;
|
||
|
return u || d
|
||
|
? Math.min(u ? e(s, t, a) : c, d ? e(l, r, a) : c)
|
||
|
: "none";
|
||
|
}
|
||
|
(o.configMerge = function () {
|
||
|
return o.merge(
|
||
|
o.clone(arguments[0]),
|
||
|
[].slice.call(arguments, 1),
|
||
|
{
|
||
|
merger: function (e, i, n, a) {
|
||
|
var r = i[e] || {},
|
||
|
s = n[e];
|
||
|
"scales" === e
|
||
|
? (i[e] = o.scaleMerge(r, s))
|
||
|
: "scale" === e
|
||
|
? (i[e] = o.merge(r, [
|
||
|
t.scaleService.getScaleDefaults(s.type),
|
||
|
s,
|
||
|
]))
|
||
|
: o._merger(e, i, n, a);
|
||
|
},
|
||
|
}
|
||
|
);
|
||
|
}),
|
||
|
(o.scaleMerge = function () {
|
||
|
return o.merge(
|
||
|
o.clone(arguments[0]),
|
||
|
[].slice.call(arguments, 1),
|
||
|
{
|
||
|
merger: function (e, i, n, a) {
|
||
|
if ("xAxes" === e || "yAxes" === e) {
|
||
|
var r,
|
||
|
s,
|
||
|
l,
|
||
|
u = n[e].length;
|
||
|
for (i[e] || (i[e] = []), r = 0; r < u; ++r)
|
||
|
(l = n[e][r]),
|
||
|
(s = o.valueOrDefault(
|
||
|
l.type,
|
||
|
"xAxes" === e ? "category" : "linear"
|
||
|
)),
|
||
|
r >= i[e].length && i[e].push({}),
|
||
|
!i[e][r].type || (l.type && l.type !== i[e][r].type)
|
||
|
? o.merge(i[e][r], [
|
||
|
t.scaleService.getScaleDefaults(s),
|
||
|
l,
|
||
|
])
|
||
|
: o.merge(i[e][r], l);
|
||
|
} else o._merger(e, i, n, a);
|
||
|
},
|
||
|
}
|
||
|
);
|
||
|
}),
|
||
|
(o.where = function (t, e) {
|
||
|
if (o.isArray(t) && Array.prototype.filter) return t.filter(e);
|
||
|
var i = [];
|
||
|
return (
|
||
|
o.each(t, function (t) {
|
||
|
e(t) && i.push(t);
|
||
|
}),
|
||
|
i
|
||
|
);
|
||
|
}),
|
||
|
(o.findIndex = Array.prototype.findIndex
|
||
|
? function (t, e, i) {
|
||
|
return t.findIndex(e, i);
|
||
|
}
|
||
|
: function (t, e, i) {
|
||
|
i = void 0 === i ? t : i;
|
||
|
for (var n = 0, a = t.length; n < a; ++n)
|
||
|
if (e.call(i, t[n], n, t)) return n;
|
||
|
return -1;
|
||
|
}),
|
||
|
(o.findNextWhere = function (t, e, i) {
|
||
|
o.isNullOrUndef(i) && (i = -1);
|
||
|
for (var n = i + 1; n < t.length; n++) {
|
||
|
var a = t[n];
|
||
|
if (e(a)) return a;
|
||
|
}
|
||
|
}),
|
||
|
(o.findPreviousWhere = function (t, e, i) {
|
||
|
o.isNullOrUndef(i) && (i = t.length);
|
||
|
for (var n = i - 1; n >= 0; n--) {
|
||
|
var a = t[n];
|
||
|
if (e(a)) return a;
|
||
|
}
|
||
|
}),
|
||
|
(o.isNumber = function (t) {
|
||
|
return !isNaN(parseFloat(t)) && isFinite(t);
|
||
|
}),
|
||
|
(o.almostEquals = function (t, e, i) {
|
||
|
return Math.abs(t - e) < i;
|
||
|
}),
|
||
|
(o.almostWhole = function (t, e) {
|
||
|
var i = Math.round(t);
|
||
|
return i - e < t && i + e > t;
|
||
|
}),
|
||
|
(o.max = function (t) {
|
||
|
return t.reduce(function (t, e) {
|
||
|
return isNaN(e) ? t : Math.max(t, e);
|
||
|
}, Number.NEGATIVE_INFINITY);
|
||
|
}),
|
||
|
(o.min = function (t) {
|
||
|
return t.reduce(function (t, e) {
|
||
|
return isNaN(e) ? t : Math.min(t, e);
|
||
|
}, Number.POSITIVE_INFINITY);
|
||
|
}),
|
||
|
(o.sign = Math.sign
|
||
|
? function (t) {
|
||
|
return Math.sign(t);
|
||
|
}
|
||
|
: function (t) {
|
||
|
return 0 === (t = +t) || isNaN(t) ? t : t > 0 ? 1 : -1;
|
||
|
}),
|
||
|
(o.log10 = Math.log10
|
||
|
? function (t) {
|
||
|
return Math.log10(t);
|
||
|
}
|
||
|
: function (t) {
|
||
|
var e = Math.log(t) * Math.LOG10E,
|
||
|
i = Math.round(e);
|
||
|
return t === Math.pow(10, i) ? i : e;
|
||
|
}),
|
||
|
(o.toRadians = function (t) {
|
||
|
return t * (Math.PI / 180);
|
||
|
}),
|
||
|
(o.toDegrees = function (t) {
|
||
|
return t * (180 / Math.PI);
|
||
|
}),
|
||
|
(o.getAngleFromPoint = function (t, e) {
|
||
|
var i = e.x - t.x,
|
||
|
n = e.y - t.y,
|
||
|
a = Math.sqrt(i * i + n * n),
|
||
|
o = Math.atan2(n, i);
|
||
|
return (
|
||
|
o < -0.5 * Math.PI && (o += 2 * Math.PI),
|
||
|
{ angle: o, distance: a }
|
||
|
);
|
||
|
}),
|
||
|
(o.distanceBetweenPoints = function (t, e) {
|
||
|
return Math.sqrt(
|
||
|
Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2)
|
||
|
);
|
||
|
}),
|
||
|
(o.aliasPixel = function (t) {
|
||
|
return t % 2 == 0 ? 0 : 0.5;
|
||
|
}),
|
||
|
(o.splineCurve = function (t, e, i, n) {
|
||
|
var a = t.skip ? e : t,
|
||
|
o = e,
|
||
|
r = i.skip ? e : i,
|
||
|
s = Math.sqrt(
|
||
|
Math.pow(o.x - a.x, 2) + Math.pow(o.y - a.y, 2)
|
||
|
),
|
||
|
l = Math.sqrt(
|
||
|
Math.pow(r.x - o.x, 2) + Math.pow(r.y - o.y, 2)
|
||
|
),
|
||
|
u = s / (s + l),
|
||
|
d = l / (s + l),
|
||
|
c = n * (u = isNaN(u) ? 0 : u),
|
||
|
h = n * (d = isNaN(d) ? 0 : d);
|
||
|
return {
|
||
|
previous: {
|
||
|
x: o.x - c * (r.x - a.x),
|
||
|
y: o.y - c * (r.y - a.y),
|
||
|
},
|
||
|
next: { x: o.x + h * (r.x - a.x), y: o.y + h * (r.y - a.y) },
|
||
|
};
|
||
|
}),
|
||
|
(o.EPSILON = Number.EPSILON || 1e-14),
|
||
|
(o.splineCurveMonotone = function (t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
a,
|
||
|
r,
|
||
|
s,
|
||
|
l,
|
||
|
u,
|
||
|
d,
|
||
|
c = (t || []).map(function (t) {
|
||
|
return { model: t._model, deltaK: 0, mK: 0 };
|
||
|
}),
|
||
|
h = c.length;
|
||
|
for (e = 0; e < h; ++e)
|
||
|
if (!(n = c[e]).model.skip) {
|
||
|
if (
|
||
|
((i = e > 0 ? c[e - 1] : null),
|
||
|
(a = e < h - 1 ? c[e + 1] : null) && !a.model.skip)
|
||
|
) {
|
||
|
var f = a.model.x - n.model.x;
|
||
|
n.deltaK = 0 !== f ? (a.model.y - n.model.y) / f : 0;
|
||
|
}
|
||
|
!i || i.model.skip
|
||
|
? (n.mK = n.deltaK)
|
||
|
: !a || a.model.skip
|
||
|
? (n.mK = i.deltaK)
|
||
|
: this.sign(i.deltaK) !== this.sign(n.deltaK)
|
||
|
? (n.mK = 0)
|
||
|
: (n.mK = (i.deltaK + n.deltaK) / 2);
|
||
|
}
|
||
|
for (e = 0; e < h - 1; ++e)
|
||
|
(n = c[e]),
|
||
|
(a = c[e + 1]),
|
||
|
n.model.skip ||
|
||
|
a.model.skip ||
|
||
|
(o.almostEquals(n.deltaK, 0, this.EPSILON)
|
||
|
? (n.mK = a.mK = 0)
|
||
|
: ((r = n.mK / n.deltaK),
|
||
|
(s = a.mK / n.deltaK),
|
||
|
(u = Math.pow(r, 2) + Math.pow(s, 2)) <= 9 ||
|
||
|
((l = 3 / Math.sqrt(u)),
|
||
|
(n.mK = r * l * n.deltaK),
|
||
|
(a.mK = s * l * n.deltaK))));
|
||
|
for (e = 0; e < h; ++e)
|
||
|
(n = c[e]).model.skip ||
|
||
|
((i = e > 0 ? c[e - 1] : null),
|
||
|
(a = e < h - 1 ? c[e + 1] : null),
|
||
|
i &&
|
||
|
!i.model.skip &&
|
||
|
((d = (n.model.x - i.model.x) / 3),
|
||
|
(n.model.controlPointPreviousX = n.model.x - d),
|
||
|
(n.model.controlPointPreviousY = n.model.y - d * n.mK)),
|
||
|
a &&
|
||
|
!a.model.skip &&
|
||
|
((d = (a.model.x - n.model.x) / 3),
|
||
|
(n.model.controlPointNextX = n.model.x + d),
|
||
|
(n.model.controlPointNextY = n.model.y + d * n.mK)));
|
||
|
}),
|
||
|
(o.nextItem = function (t, e, i) {
|
||
|
return i
|
||
|
? e >= t.length - 1
|
||
|
? t[0]
|
||
|
: t[e + 1]
|
||
|
: e >= t.length - 1
|
||
|
? t[t.length - 1]
|
||
|
: t[e + 1];
|
||
|
}),
|
||
|
(o.previousItem = function (t, e, i) {
|
||
|
return i
|
||
|
? e <= 0
|
||
|
? t[t.length - 1]
|
||
|
: t[e - 1]
|
||
|
: e <= 0
|
||
|
? t[0]
|
||
|
: t[e - 1];
|
||
|
}),
|
||
|
(o.niceNum = function (t, e) {
|
||
|
var i = Math.floor(o.log10(t)),
|
||
|
n = t / Math.pow(10, i);
|
||
|
return (
|
||
|
(e
|
||
|
? n < 1.5
|
||
|
? 1
|
||
|
: n < 3
|
||
|
? 2
|
||
|
: n < 7
|
||
|
? 5
|
||
|
: 10
|
||
|
: n <= 1
|
||
|
? 1
|
||
|
: n <= 2
|
||
|
? 2
|
||
|
: n <= 5
|
||
|
? 5
|
||
|
: 10) * Math.pow(10, i)
|
||
|
);
|
||
|
}),
|
||
|
(o.requestAnimFrame =
|
||
|
"undefined" == typeof window
|
||
|
? function (t) {
|
||
|
t();
|
||
|
}
|
||
|
: window.requestAnimationFrame ||
|
||
|
window.webkitRequestAnimationFrame ||
|
||
|
window.mozRequestAnimationFrame ||
|
||
|
window.oRequestAnimationFrame ||
|
||
|
window.msRequestAnimationFrame ||
|
||
|
function (t) {
|
||
|
return window.setTimeout(t, 1e3 / 60);
|
||
|
}),
|
||
|
(o.getRelativePosition = function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a = t.originalEvent || t,
|
||
|
r = t.currentTarget || t.srcElement,
|
||
|
s = r.getBoundingClientRect(),
|
||
|
l = a.touches;
|
||
|
l && l.length > 0
|
||
|
? ((i = l[0].clientX), (n = l[0].clientY))
|
||
|
: ((i = a.clientX), (n = a.clientY));
|
||
|
var u = parseFloat(o.getStyle(r, "padding-left")),
|
||
|
d = parseFloat(o.getStyle(r, "padding-top")),
|
||
|
c = parseFloat(o.getStyle(r, "padding-right")),
|
||
|
h = parseFloat(o.getStyle(r, "padding-bottom")),
|
||
|
f = s.right - s.left - u - c,
|
||
|
g = s.bottom - s.top - d - h;
|
||
|
return {
|
||
|
x: (i = Math.round(
|
||
|
(((i - s.left - u) / f) * r.width) /
|
||
|
e.currentDevicePixelRatio
|
||
|
)),
|
||
|
y: (n = Math.round(
|
||
|
(((n - s.top - d) / g) * r.height) /
|
||
|
e.currentDevicePixelRatio
|
||
|
)),
|
||
|
};
|
||
|
}),
|
||
|
(o.getConstraintWidth = function (t) {
|
||
|
return r(t, "max-width", "clientWidth");
|
||
|
}),
|
||
|
(o.getConstraintHeight = function (t) {
|
||
|
return r(t, "max-height", "clientHeight");
|
||
|
}),
|
||
|
(o.getMaximumWidth = function (t) {
|
||
|
var e = t.parentNode;
|
||
|
if (!e) return t.clientWidth;
|
||
|
var i = parseInt(o.getStyle(e, "padding-left"), 10),
|
||
|
n = parseInt(o.getStyle(e, "padding-right"), 10),
|
||
|
a = e.clientWidth - i - n,
|
||
|
r = o.getConstraintWidth(t);
|
||
|
return isNaN(r) ? a : Math.min(a, r);
|
||
|
}),
|
||
|
(o.getMaximumHeight = function (t) {
|
||
|
var e = t.parentNode;
|
||
|
if (!e) return t.clientHeight;
|
||
|
var i = parseInt(o.getStyle(e, "padding-top"), 10),
|
||
|
n = parseInt(o.getStyle(e, "padding-bottom"), 10),
|
||
|
a = e.clientHeight - i - n,
|
||
|
r = o.getConstraintHeight(t);
|
||
|
return isNaN(r) ? a : Math.min(a, r);
|
||
|
}),
|
||
|
(o.getStyle = function (t, e) {
|
||
|
return t.currentStyle
|
||
|
? t.currentStyle[e]
|
||
|
: document.defaultView
|
||
|
.getComputedStyle(t, null)
|
||
|
.getPropertyValue(e);
|
||
|
}),
|
||
|
(o.retinaScale = function (t, e) {
|
||
|
var i = (t.currentDevicePixelRatio =
|
||
|
e || window.devicePixelRatio || 1);
|
||
|
if (1 !== i) {
|
||
|
var n = t.canvas,
|
||
|
a = t.height,
|
||
|
o = t.width;
|
||
|
(n.height = a * i),
|
||
|
(n.width = o * i),
|
||
|
t.ctx.scale(i, i),
|
||
|
n.style.height ||
|
||
|
n.style.width ||
|
||
|
((n.style.height = a + "px"), (n.style.width = o + "px"));
|
||
|
}
|
||
|
}),
|
||
|
(o.fontString = function (t, e, i) {
|
||
|
return e + " " + t + "px " + i;
|
||
|
}),
|
||
|
(o.longestText = function (t, e, i, n) {
|
||
|
var a = ((n = n || {}).data = n.data || {}),
|
||
|
r = (n.garbageCollect = n.garbageCollect || []);
|
||
|
n.font !== e &&
|
||
|
((a = n.data = {}),
|
||
|
(r = n.garbageCollect = []),
|
||
|
(n.font = e)),
|
||
|
(t.font = e);
|
||
|
var s = 0;
|
||
|
o.each(i, function (e) {
|
||
|
null != e && !0 !== o.isArray(e)
|
||
|
? (s = o.measureText(t, a, r, s, e))
|
||
|
: o.isArray(e) &&
|
||
|
o.each(e, function (e) {
|
||
|
null == e ||
|
||
|
o.isArray(e) ||
|
||
|
(s = o.measureText(t, a, r, s, e));
|
||
|
});
|
||
|
});
|
||
|
var l = r.length / 2;
|
||
|
if (l > i.length) {
|
||
|
for (var u = 0; u < l; u++) delete a[r[u]];
|
||
|
r.splice(0, l);
|
||
|
}
|
||
|
return s;
|
||
|
}),
|
||
|
(o.measureText = function (t, e, i, n, a) {
|
||
|
var o = e[a];
|
||
|
return (
|
||
|
o || ((o = e[a] = t.measureText(a).width), i.push(a)),
|
||
|
o > n && (n = o),
|
||
|
n
|
||
|
);
|
||
|
}),
|
||
|
(o.numberOfLabelLines = function (t) {
|
||
|
var e = 1;
|
||
|
return (
|
||
|
o.each(t, function (t) {
|
||
|
o.isArray(t) && t.length > e && (e = t.length);
|
||
|
}),
|
||
|
e
|
||
|
);
|
||
|
}),
|
||
|
(o.color = n
|
||
|
? function (t) {
|
||
|
return (
|
||
|
t instanceof CanvasGradient &&
|
||
|
(t = a.global.defaultColor),
|
||
|
n(t)
|
||
|
);
|
||
|
}
|
||
|
: function (t) {
|
||
|
return console.error("Color.js not found!"), t;
|
||
|
}),
|
||
|
(o.getHoverColor = function (t) {
|
||
|
return t instanceof CanvasPattern
|
||
|
? t
|
||
|
: o.color(t).saturate(0.5).darken(0.1).rgbString();
|
||
|
});
|
||
|
};
|
||
|
},
|
||
|
{ 25: 25, 3: 3, 45: 45 },
|
||
|
],
|
||
|
28: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45);
|
||
|
function a(t, e) {
|
||
|
return t.native ? { x: t.x, y: t.y } : n.getRelativePosition(t, e);
|
||
|
}
|
||
|
function o(t, e) {
|
||
|
var i, n, a, o, r;
|
||
|
for (n = 0, o = t.data.datasets.length; n < o; ++n)
|
||
|
if (t.isDatasetVisible(n))
|
||
|
for (
|
||
|
a = 0, r = (i = t.getDatasetMeta(n)).data.length;
|
||
|
a < r;
|
||
|
++a
|
||
|
) {
|
||
|
var s = i.data[a];
|
||
|
s._view.skip || e(s);
|
||
|
}
|
||
|
}
|
||
|
function r(t, e) {
|
||
|
var i = [];
|
||
|
return (
|
||
|
o(t, function (t) {
|
||
|
t.inRange(e.x, e.y) && i.push(t);
|
||
|
}),
|
||
|
i
|
||
|
);
|
||
|
}
|
||
|
function s(t, e, i, n) {
|
||
|
var a = Number.POSITIVE_INFINITY,
|
||
|
r = [];
|
||
|
return (
|
||
|
o(t, function (t) {
|
||
|
if (!i || t.inRange(e.x, e.y)) {
|
||
|
var o = t.getCenterPoint(),
|
||
|
s = n(e, o);
|
||
|
s < a ? ((r = [t]), (a = s)) : s === a && r.push(t);
|
||
|
}
|
||
|
}),
|
||
|
r
|
||
|
);
|
||
|
}
|
||
|
function l(t) {
|
||
|
var e = -1 !== t.indexOf("x"),
|
||
|
i = -1 !== t.indexOf("y");
|
||
|
return function (t, n) {
|
||
|
var a = e ? Math.abs(t.x - n.x) : 0,
|
||
|
o = i ? Math.abs(t.y - n.y) : 0;
|
||
|
return Math.sqrt(Math.pow(a, 2) + Math.pow(o, 2));
|
||
|
};
|
||
|
}
|
||
|
function u(t, e, i) {
|
||
|
var n = a(e, t);
|
||
|
i.axis = i.axis || "x";
|
||
|
var o = l(i.axis),
|
||
|
u = i.intersect ? r(t, n) : s(t, n, !1, o),
|
||
|
d = [];
|
||
|
return u.length
|
||
|
? (t.data.datasets.forEach(function (e, i) {
|
||
|
if (t.isDatasetVisible(i)) {
|
||
|
var n = t.getDatasetMeta(i).data[u[0]._index];
|
||
|
n && !n._view.skip && d.push(n);
|
||
|
}
|
||
|
}),
|
||
|
d)
|
||
|
: [];
|
||
|
}
|
||
|
e.exports = {
|
||
|
modes: {
|
||
|
single: function (t, e) {
|
||
|
var i = a(e, t),
|
||
|
n = [];
|
||
|
return (
|
||
|
o(t, function (t) {
|
||
|
if (t.inRange(i.x, i.y)) return n.push(t), n;
|
||
|
}),
|
||
|
n.slice(0, 1)
|
||
|
);
|
||
|
},
|
||
|
label: u,
|
||
|
index: u,
|
||
|
dataset: function (t, e, i) {
|
||
|
var n = a(e, t);
|
||
|
i.axis = i.axis || "xy";
|
||
|
var o = l(i.axis),
|
||
|
u = i.intersect ? r(t, n) : s(t, n, !1, o);
|
||
|
return (
|
||
|
u.length > 0 &&
|
||
|
(u = t.getDatasetMeta(u[0]._datasetIndex).data),
|
||
|
u
|
||
|
);
|
||
|
},
|
||
|
"x-axis": function (t, e) {
|
||
|
return u(t, e, { intersect: !1 });
|
||
|
},
|
||
|
point: function (t, e) {
|
||
|
return r(t, a(e, t));
|
||
|
},
|
||
|
nearest: function (t, e, i) {
|
||
|
var n = a(e, t);
|
||
|
i.axis = i.axis || "xy";
|
||
|
var o = l(i.axis),
|
||
|
r = s(t, n, i.intersect, o);
|
||
|
return (
|
||
|
r.length > 1 &&
|
||
|
r.sort(function (t, e) {
|
||
|
var i = t.getArea() - e.getArea();
|
||
|
return (
|
||
|
0 === i && (i = t._datasetIndex - e._datasetIndex), i
|
||
|
);
|
||
|
}),
|
||
|
r.slice(0, 1)
|
||
|
);
|
||
|
},
|
||
|
x: function (t, e, i) {
|
||
|
var n = a(e, t),
|
||
|
r = [],
|
||
|
s = !1;
|
||
|
return (
|
||
|
o(t, function (t) {
|
||
|
t.inXRange(n.x) && r.push(t),
|
||
|
t.inRange(n.x, n.y) && (s = !0);
|
||
|
}),
|
||
|
i.intersect && !s && (r = []),
|
||
|
r
|
||
|
);
|
||
|
},
|
||
|
y: function (t, e, i) {
|
||
|
var n = a(e, t),
|
||
|
r = [],
|
||
|
s = !1;
|
||
|
return (
|
||
|
o(t, function (t) {
|
||
|
t.inYRange(n.y) && r.push(t),
|
||
|
t.inRange(n.x, n.y) && (s = !0);
|
||
|
}),
|
||
|
i.intersect && !s && (r = []),
|
||
|
r
|
||
|
);
|
||
|
},
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{ 45: 45 },
|
||
|
],
|
||
|
29: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
t(25)._set("global", {
|
||
|
responsive: !0,
|
||
|
responsiveAnimationDuration: 0,
|
||
|
maintainAspectRatio: !0,
|
||
|
events: [
|
||
|
"mousemove",
|
||
|
"mouseout",
|
||
|
"click",
|
||
|
"touchstart",
|
||
|
"touchmove",
|
||
|
],
|
||
|
hover: {
|
||
|
onHover: null,
|
||
|
mode: "nearest",
|
||
|
intersect: !0,
|
||
|
animationDuration: 400,
|
||
|
},
|
||
|
onClick: null,
|
||
|
defaultColor: "rgba(0,0,0,0.1)",
|
||
|
defaultFontColor: "#666",
|
||
|
defaultFontFamily:
|
||
|
"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",
|
||
|
defaultFontSize: 12,
|
||
|
defaultFontStyle: "normal",
|
||
|
showLines: !0,
|
||
|
elements: {},
|
||
|
layout: { padding: { top: 0, right: 0, bottom: 0, left: 0 } },
|
||
|
}),
|
||
|
(e.exports = function () {
|
||
|
var t = function (t, e) {
|
||
|
return this.construct(t, e), this;
|
||
|
};
|
||
|
return (t.Chart = t), t;
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25 },
|
||
|
],
|
||
|
30: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45);
|
||
|
function a(t, e) {
|
||
|
return n.where(t, function (t) {
|
||
|
return t.position === e;
|
||
|
});
|
||
|
}
|
||
|
function o(t, e) {
|
||
|
t.forEach(function (t, e) {
|
||
|
return (t._tmpIndex_ = e), t;
|
||
|
}),
|
||
|
t.sort(function (t, i) {
|
||
|
var n = e ? i : t,
|
||
|
a = e ? t : i;
|
||
|
return n.weight === a.weight
|
||
|
? n._tmpIndex_ - a._tmpIndex_
|
||
|
: n.weight - a.weight;
|
||
|
}),
|
||
|
t.forEach(function (t) {
|
||
|
delete t._tmpIndex_;
|
||
|
});
|
||
|
}
|
||
|
e.exports = {
|
||
|
defaults: {},
|
||
|
addBox: function (t, e) {
|
||
|
t.boxes || (t.boxes = []),
|
||
|
(e.fullWidth = e.fullWidth || !1),
|
||
|
(e.position = e.position || "top"),
|
||
|
(e.weight = e.weight || 0),
|
||
|
t.boxes.push(e);
|
||
|
},
|
||
|
removeBox: function (t, e) {
|
||
|
var i = t.boxes ? t.boxes.indexOf(e) : -1;
|
||
|
-1 !== i && t.boxes.splice(i, 1);
|
||
|
},
|
||
|
configure: function (t, e, i) {
|
||
|
for (
|
||
|
var n,
|
||
|
a = ["fullWidth", "position", "weight"],
|
||
|
o = a.length,
|
||
|
r = 0;
|
||
|
r < o;
|
||
|
++r
|
||
|
)
|
||
|
(n = a[r]), i.hasOwnProperty(n) && (e[n] = i[n]);
|
||
|
},
|
||
|
update: function (t, e, i) {
|
||
|
if (t) {
|
||
|
var r = t.options.layout || {},
|
||
|
s = n.options.toPadding(r.padding),
|
||
|
l = s.left,
|
||
|
u = s.right,
|
||
|
d = s.top,
|
||
|
c = s.bottom,
|
||
|
h = a(t.boxes, "left"),
|
||
|
f = a(t.boxes, "right"),
|
||
|
g = a(t.boxes, "top"),
|
||
|
p = a(t.boxes, "bottom"),
|
||
|
m = a(t.boxes, "chartArea");
|
||
|
o(h, !0), o(f, !1), o(g, !0), o(p, !1);
|
||
|
var v = e - l - u,
|
||
|
b = i - d - c,
|
||
|
x = b / 2,
|
||
|
y = (e - v / 2) / (h.length + f.length),
|
||
|
k = (i - x) / (g.length + p.length),
|
||
|
M = v,
|
||
|
w = b,
|
||
|
S = [];
|
||
|
n.each(h.concat(f, g, p), function (t) {
|
||
|
var e,
|
||
|
i = t.isHorizontal();
|
||
|
i
|
||
|
? ((e = t.update(t.fullWidth ? v : M, k)), (w -= e.height))
|
||
|
: ((e = t.update(y, w)), (M -= e.width)),
|
||
|
S.push({ horizontal: i, minSize: e, box: t });
|
||
|
});
|
||
|
var C = 0,
|
||
|
_ = 0,
|
||
|
D = 0,
|
||
|
I = 0;
|
||
|
n.each(g.concat(p), function (t) {
|
||
|
if (t.getPadding) {
|
||
|
var e = t.getPadding();
|
||
|
(C = Math.max(C, e.left)), (_ = Math.max(_, e.right));
|
||
|
}
|
||
|
}),
|
||
|
n.each(h.concat(f), function (t) {
|
||
|
if (t.getPadding) {
|
||
|
var e = t.getPadding();
|
||
|
(D = Math.max(D, e.top)), (I = Math.max(I, e.bottom));
|
||
|
}
|
||
|
});
|
||
|
var P = l,
|
||
|
A = u,
|
||
|
T = d,
|
||
|
F = c;
|
||
|
n.each(h.concat(f), N),
|
||
|
n.each(h, function (t) {
|
||
|
P += t.width;
|
||
|
}),
|
||
|
n.each(f, function (t) {
|
||
|
A += t.width;
|
||
|
}),
|
||
|
n.each(g.concat(p), N),
|
||
|
n.each(g, function (t) {
|
||
|
T += t.height;
|
||
|
}),
|
||
|
n.each(p, function (t) {
|
||
|
F += t.height;
|
||
|
}),
|
||
|
n.each(h.concat(f), function (t) {
|
||
|
var e = n.findNextWhere(S, function (e) {
|
||
|
return e.box === t;
|
||
|
}),
|
||
|
i = { left: 0, right: 0, top: T, bottom: F };
|
||
|
e && t.update(e.minSize.width, w, i);
|
||
|
}),
|
||
|
(P = l),
|
||
|
(A = u),
|
||
|
(T = d),
|
||
|
(F = c),
|
||
|
n.each(h, function (t) {
|
||
|
P += t.width;
|
||
|
}),
|
||
|
n.each(f, function (t) {
|
||
|
A += t.width;
|
||
|
}),
|
||
|
n.each(g, function (t) {
|
||
|
T += t.height;
|
||
|
}),
|
||
|
n.each(p, function (t) {
|
||
|
F += t.height;
|
||
|
});
|
||
|
var O = Math.max(C - P, 0);
|
||
|
(P += O), (A += Math.max(_ - A, 0));
|
||
|
var R = Math.max(D - T, 0);
|
||
|
(T += R), (F += Math.max(I - F, 0));
|
||
|
var L = i - T - F,
|
||
|
z = e - P - A;
|
||
|
(z === M && L === w) ||
|
||
|
(n.each(h, function (t) {
|
||
|
t.height = L;
|
||
|
}),
|
||
|
n.each(f, function (t) {
|
||
|
t.height = L;
|
||
|
}),
|
||
|
n.each(g, function (t) {
|
||
|
t.fullWidth || (t.width = z);
|
||
|
}),
|
||
|
n.each(p, function (t) {
|
||
|
t.fullWidth || (t.width = z);
|
||
|
}),
|
||
|
(w = L),
|
||
|
(M = z));
|
||
|
var B = l + O,
|
||
|
W = d + R;
|
||
|
n.each(h.concat(g), V),
|
||
|
(B += M),
|
||
|
(W += w),
|
||
|
n.each(f, V),
|
||
|
n.each(p, V),
|
||
|
(t.chartArea = {
|
||
|
left: P,
|
||
|
top: T,
|
||
|
right: P + M,
|
||
|
bottom: T + w,
|
||
|
}),
|
||
|
n.each(m, function (e) {
|
||
|
(e.left = t.chartArea.left),
|
||
|
(e.top = t.chartArea.top),
|
||
|
(e.right = t.chartArea.right),
|
||
|
(e.bottom = t.chartArea.bottom),
|
||
|
e.update(M, w);
|
||
|
});
|
||
|
}
|
||
|
function N(t) {
|
||
|
var e = n.findNextWhere(S, function (e) {
|
||
|
return e.box === t;
|
||
|
});
|
||
|
if (e)
|
||
|
if (t.isHorizontal()) {
|
||
|
var i = {
|
||
|
left: Math.max(P, C),
|
||
|
right: Math.max(A, _),
|
||
|
top: 0,
|
||
|
bottom: 0,
|
||
|
};
|
||
|
t.update(t.fullWidth ? v : M, b / 2, i);
|
||
|
} else t.update(e.minSize.width, w);
|
||
|
}
|
||
|
function V(t) {
|
||
|
t.isHorizontal()
|
||
|
? ((t.left = t.fullWidth ? l : P),
|
||
|
(t.right = t.fullWidth ? e - u : P + M),
|
||
|
(t.top = W),
|
||
|
(t.bottom = W + t.height),
|
||
|
(W = t.bottom))
|
||
|
: ((t.left = B),
|
||
|
(t.right = B + t.width),
|
||
|
(t.top = T),
|
||
|
(t.bottom = T + w),
|
||
|
(B = t.right));
|
||
|
}
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{ 45: 45 },
|
||
|
],
|
||
|
31: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(45);
|
||
|
n._set("global", { plugins: {} }),
|
||
|
(e.exports = {
|
||
|
_plugins: [],
|
||
|
_cacheId: 0,
|
||
|
register: function (t) {
|
||
|
var e = this._plugins;
|
||
|
[].concat(t).forEach(function (t) {
|
||
|
-1 === e.indexOf(t) && e.push(t);
|
||
|
}),
|
||
|
this._cacheId++;
|
||
|
},
|
||
|
unregister: function (t) {
|
||
|
var e = this._plugins;
|
||
|
[].concat(t).forEach(function (t) {
|
||
|
var i = e.indexOf(t);
|
||
|
-1 !== i && e.splice(i, 1);
|
||
|
}),
|
||
|
this._cacheId++;
|
||
|
},
|
||
|
clear: function () {
|
||
|
(this._plugins = []), this._cacheId++;
|
||
|
},
|
||
|
count: function () {
|
||
|
return this._plugins.length;
|
||
|
},
|
||
|
getAll: function () {
|
||
|
return this._plugins;
|
||
|
},
|
||
|
notify: function (t, e, i) {
|
||
|
var n,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s,
|
||
|
l = this.descriptors(t),
|
||
|
u = l.length;
|
||
|
for (n = 0; n < u; ++n)
|
||
|
if (
|
||
|
"function" == typeof (s = (o = (a = l[n]).plugin)[e]) &&
|
||
|
((r = [t].concat(i || [])).push(a.options),
|
||
|
!1 === s.apply(o, r))
|
||
|
)
|
||
|
return !1;
|
||
|
return !0;
|
||
|
},
|
||
|
descriptors: function (t) {
|
||
|
var e = t.$plugins || (t.$plugins = {});
|
||
|
if (e.id === this._cacheId) return e.descriptors;
|
||
|
var i = [],
|
||
|
o = [],
|
||
|
r = (t && t.config) || {},
|
||
|
s = (r.options && r.options.plugins) || {};
|
||
|
return (
|
||
|
this._plugins.concat(r.plugins || []).forEach(function (t) {
|
||
|
if (-1 === i.indexOf(t)) {
|
||
|
var e = t.id,
|
||
|
r = s[e];
|
||
|
!1 !== r &&
|
||
|
(!0 === r && (r = a.clone(n.global.plugins[e])),
|
||
|
i.push(t),
|
||
|
o.push({ plugin: t, options: r || {} }));
|
||
|
}
|
||
|
}),
|
||
|
(e.descriptors = o),
|
||
|
(e.id = this._cacheId),
|
||
|
o
|
||
|
);
|
||
|
},
|
||
|
_invalidate: function (t) {
|
||
|
delete t.$plugins;
|
||
|
},
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 45: 45 },
|
||
|
],
|
||
|
32: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26),
|
||
|
o = t(45),
|
||
|
r = t(34);
|
||
|
function s(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n = [];
|
||
|
for (e = 0, i = t.length; e < i; ++e) n.push(t[e].label);
|
||
|
return n;
|
||
|
}
|
||
|
function l(t, e, i) {
|
||
|
var n = t.getPixelForTick(e);
|
||
|
return (
|
||
|
i &&
|
||
|
(n -=
|
||
|
0 === e
|
||
|
? (t.getPixelForTick(1) - n) / 2
|
||
|
: (n - t.getPixelForTick(e - 1)) / 2),
|
||
|
n
|
||
|
);
|
||
|
}
|
||
|
n._set("scale", {
|
||
|
display: !0,
|
||
|
position: "left",
|
||
|
offset: !1,
|
||
|
gridLines: {
|
||
|
display: !0,
|
||
|
color: "rgba(0, 0, 0, 0.1)",
|
||
|
lineWidth: 1,
|
||
|
drawBorder: !0,
|
||
|
drawOnChartArea: !0,
|
||
|
drawTicks: !0,
|
||
|
tickMarkLength: 10,
|
||
|
zeroLineWidth: 1,
|
||
|
zeroLineColor: "rgba(0,0,0,0.25)",
|
||
|
zeroLineBorderDash: [],
|
||
|
zeroLineBorderDashOffset: 0,
|
||
|
offsetGridLines: !1,
|
||
|
borderDash: [],
|
||
|
borderDashOffset: 0,
|
||
|
},
|
||
|
scaleLabel: {
|
||
|
display: !1,
|
||
|
labelString: "",
|
||
|
lineHeight: 1.2,
|
||
|
padding: { top: 4, bottom: 4 },
|
||
|
},
|
||
|
ticks: {
|
||
|
beginAtZero: !1,
|
||
|
minRotation: 0,
|
||
|
maxRotation: 50,
|
||
|
mirror: !1,
|
||
|
padding: 0,
|
||
|
reverse: !1,
|
||
|
display: !0,
|
||
|
autoSkip: !0,
|
||
|
autoSkipPadding: 0,
|
||
|
labelOffset: 0,
|
||
|
callback: r.formatters.values,
|
||
|
minor: {},
|
||
|
major: {},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
function e(t, e, i) {
|
||
|
return o.isArray(e)
|
||
|
? o.longestText(t, i, e)
|
||
|
: t.measureText(e).width;
|
||
|
}
|
||
|
function i(t) {
|
||
|
var e = o.valueOrDefault,
|
||
|
i = n.global,
|
||
|
a = e(t.fontSize, i.defaultFontSize),
|
||
|
r = e(t.fontStyle, i.defaultFontStyle),
|
||
|
s = e(t.fontFamily, i.defaultFontFamily);
|
||
|
return {
|
||
|
size: a,
|
||
|
style: r,
|
||
|
family: s,
|
||
|
font: o.fontString(a, r, s),
|
||
|
};
|
||
|
}
|
||
|
function r(t) {
|
||
|
return o.options.toLineHeight(
|
||
|
o.valueOrDefault(t.lineHeight, 1.2),
|
||
|
o.valueOrDefault(t.fontSize, n.global.defaultFontSize)
|
||
|
);
|
||
|
}
|
||
|
t.Scale = a.extend({
|
||
|
getPadding: function () {
|
||
|
return {
|
||
|
left: this.paddingLeft || 0,
|
||
|
top: this.paddingTop || 0,
|
||
|
right: this.paddingRight || 0,
|
||
|
bottom: this.paddingBottom || 0,
|
||
|
};
|
||
|
},
|
||
|
getTicks: function () {
|
||
|
return this._ticks;
|
||
|
},
|
||
|
mergeTicksOptions: function () {
|
||
|
var t = this.options.ticks;
|
||
|
for (var e in (!1 === t.minor && (t.minor = { display: !1 }),
|
||
|
!1 === t.major && (t.major = { display: !1 }),
|
||
|
t))
|
||
|
"major" !== e &&
|
||
|
"minor" !== e &&
|
||
|
(void 0 === t.minor[e] && (t.minor[e] = t[e]),
|
||
|
void 0 === t.major[e] && (t.major[e] = t[e]));
|
||
|
},
|
||
|
beforeUpdate: function () {
|
||
|
o.callback(this.options.beforeUpdate, [this]);
|
||
|
},
|
||
|
update: function (t, e, i) {
|
||
|
var n,
|
||
|
a,
|
||
|
r,
|
||
|
s,
|
||
|
l,
|
||
|
u,
|
||
|
d = this;
|
||
|
for (
|
||
|
d.beforeUpdate(),
|
||
|
d.maxWidth = t,
|
||
|
d.maxHeight = e,
|
||
|
d.margins = o.extend(
|
||
|
{ left: 0, right: 0, top: 0, bottom: 0 },
|
||
|
i
|
||
|
),
|
||
|
d.longestTextCache = d.longestTextCache || {},
|
||
|
d.beforeSetDimensions(),
|
||
|
d.setDimensions(),
|
||
|
d.afterSetDimensions(),
|
||
|
d.beforeDataLimits(),
|
||
|
d.determineDataLimits(),
|
||
|
d.afterDataLimits(),
|
||
|
d.beforeBuildTicks(),
|
||
|
l = d.buildTicks() || [],
|
||
|
d.afterBuildTicks(),
|
||
|
d.beforeTickToLabelConversion(),
|
||
|
r = d.convertTicksToLabels(l) || d.ticks,
|
||
|
d.afterTickToLabelConversion(),
|
||
|
d.ticks = r,
|
||
|
n = 0,
|
||
|
a = r.length;
|
||
|
n < a;
|
||
|
++n
|
||
|
)
|
||
|
(s = r[n]),
|
||
|
(u = l[n])
|
||
|
? (u.label = s)
|
||
|
: l.push((u = { label: s, major: !1 }));
|
||
|
return (
|
||
|
(d._ticks = l),
|
||
|
d.beforeCalculateTickRotation(),
|
||
|
d.calculateTickRotation(),
|
||
|
d.afterCalculateTickRotation(),
|
||
|
d.beforeFit(),
|
||
|
d.fit(),
|
||
|
d.afterFit(),
|
||
|
d.afterUpdate(),
|
||
|
d.minSize
|
||
|
);
|
||
|
},
|
||
|
afterUpdate: function () {
|
||
|
o.callback(this.options.afterUpdate, [this]);
|
||
|
},
|
||
|
beforeSetDimensions: function () {
|
||
|
o.callback(this.options.beforeSetDimensions, [this]);
|
||
|
},
|
||
|
setDimensions: function () {
|
||
|
var t = this;
|
||
|
t.isHorizontal()
|
||
|
? ((t.width = t.maxWidth),
|
||
|
(t.left = 0),
|
||
|
(t.right = t.width))
|
||
|
: ((t.height = t.maxHeight),
|
||
|
(t.top = 0),
|
||
|
(t.bottom = t.height)),
|
||
|
(t.paddingLeft = 0),
|
||
|
(t.paddingTop = 0),
|
||
|
(t.paddingRight = 0),
|
||
|
(t.paddingBottom = 0);
|
||
|
},
|
||
|
afterSetDimensions: function () {
|
||
|
o.callback(this.options.afterSetDimensions, [this]);
|
||
|
},
|
||
|
beforeDataLimits: function () {
|
||
|
o.callback(this.options.beforeDataLimits, [this]);
|
||
|
},
|
||
|
determineDataLimits: o.noop,
|
||
|
afterDataLimits: function () {
|
||
|
o.callback(this.options.afterDataLimits, [this]);
|
||
|
},
|
||
|
beforeBuildTicks: function () {
|
||
|
o.callback(this.options.beforeBuildTicks, [this]);
|
||
|
},
|
||
|
buildTicks: o.noop,
|
||
|
afterBuildTicks: function () {
|
||
|
o.callback(this.options.afterBuildTicks, [this]);
|
||
|
},
|
||
|
beforeTickToLabelConversion: function () {
|
||
|
o.callback(this.options.beforeTickToLabelConversion, [this]);
|
||
|
},
|
||
|
convertTicksToLabels: function () {
|
||
|
var t = this.options.ticks;
|
||
|
this.ticks = this.ticks.map(
|
||
|
t.userCallback || t.callback,
|
||
|
this
|
||
|
);
|
||
|
},
|
||
|
afterTickToLabelConversion: function () {
|
||
|
o.callback(this.options.afterTickToLabelConversion, [this]);
|
||
|
},
|
||
|
beforeCalculateTickRotation: function () {
|
||
|
o.callback(this.options.beforeCalculateTickRotation, [this]);
|
||
|
},
|
||
|
calculateTickRotation: function () {
|
||
|
var t = this,
|
||
|
e = t.ctx,
|
||
|
n = t.options.ticks,
|
||
|
a = s(t._ticks),
|
||
|
r = i(n);
|
||
|
e.font = r.font;
|
||
|
var l = n.minRotation || 0;
|
||
|
if (a.length && t.options.display && t.isHorizontal())
|
||
|
for (
|
||
|
var u,
|
||
|
d = o.longestText(e, r.font, a, t.longestTextCache),
|
||
|
c = d,
|
||
|
h = t.getPixelForTick(1) - t.getPixelForTick(0) - 6;
|
||
|
c > h && l < n.maxRotation;
|
||
|
|
||
|
) {
|
||
|
var f = o.toRadians(l);
|
||
|
if (((u = Math.cos(f)), Math.sin(f) * d > t.maxHeight)) {
|
||
|
l--;
|
||
|
break;
|
||
|
}
|
||
|
l++, (c = u * d);
|
||
|
}
|
||
|
t.labelRotation = l;
|
||
|
},
|
||
|
afterCalculateTickRotation: function () {
|
||
|
o.callback(this.options.afterCalculateTickRotation, [this]);
|
||
|
},
|
||
|
beforeFit: function () {
|
||
|
o.callback(this.options.beforeFit, [this]);
|
||
|
},
|
||
|
fit: function () {
|
||
|
var t = this,
|
||
|
n = (t.minSize = { width: 0, height: 0 }),
|
||
|
a = s(t._ticks),
|
||
|
l = t.options,
|
||
|
u = l.ticks,
|
||
|
d = l.scaleLabel,
|
||
|
c = l.gridLines,
|
||
|
h = l.display,
|
||
|
f = t.isHorizontal(),
|
||
|
g = i(u),
|
||
|
p = l.gridLines.tickMarkLength;
|
||
|
if (
|
||
|
((n.width = f
|
||
|
? t.isFullWidth()
|
||
|
? t.maxWidth - t.margins.left - t.margins.right
|
||
|
: t.maxWidth
|
||
|
: h && c.drawTicks
|
||
|
? p
|
||
|
: 0),
|
||
|
(n.height = f ? (h && c.drawTicks ? p : 0) : t.maxHeight),
|
||
|
d.display && h)
|
||
|
) {
|
||
|
var m = r(d) + o.options.toPadding(d.padding).height;
|
||
|
f ? (n.height += m) : (n.width += m);
|
||
|
}
|
||
|
if (u.display && h) {
|
||
|
var v = o.longestText(t.ctx, g.font, a, t.longestTextCache),
|
||
|
b = o.numberOfLabelLines(a),
|
||
|
x = 0.5 * g.size,
|
||
|
y = t.options.ticks.padding;
|
||
|
if (f) {
|
||
|
t.longestLabelWidth = v;
|
||
|
var k = o.toRadians(t.labelRotation),
|
||
|
M = Math.cos(k),
|
||
|
w = Math.sin(k) * v + g.size * b + x * (b - 1) + x;
|
||
|
(n.height = Math.min(t.maxHeight, n.height + w + y)),
|
||
|
(t.ctx.font = g.font);
|
||
|
var S = e(t.ctx, a[0], g.font),
|
||
|
C = e(t.ctx, a[a.length - 1], g.font);
|
||
|
0 !== t.labelRotation
|
||
|
? ((t.paddingLeft =
|
||
|
"bottom" === l.position ? M * S + 3 : M * x + 3),
|
||
|
(t.paddingRight =
|
||
|
"bottom" === l.position ? M * x + 3 : M * C + 3))
|
||
|
: ((t.paddingLeft = S / 2 + 3),
|
||
|
(t.paddingRight = C / 2 + 3));
|
||
|
} else
|
||
|
u.mirror ? (v = 0) : (v += y + x),
|
||
|
(n.width = Math.min(t.maxWidth, n.width + v)),
|
||
|
(t.paddingTop = g.size / 2),
|
||
|
(t.paddingBottom = g.size / 2);
|
||
|
}
|
||
|
t.handleMargins(), (t.width = n.width), (t.height = n.height);
|
||
|
},
|
||
|
handleMargins: function () {
|
||
|
var t = this;
|
||
|
t.margins &&
|
||
|
((t.paddingLeft = Math.max(
|
||
|
t.paddingLeft - t.margins.left,
|
||
|
0
|
||
|
)),
|
||
|
(t.paddingTop = Math.max(t.paddingTop - t.margins.top, 0)),
|
||
|
(t.paddingRight = Math.max(
|
||
|
t.paddingRight - t.margins.right,
|
||
|
0
|
||
|
)),
|
||
|
(t.paddingBottom = Math.max(
|
||
|
t.paddingBottom - t.margins.bottom,
|
||
|
0
|
||
|
)));
|
||
|
},
|
||
|
afterFit: function () {
|
||
|
o.callback(this.options.afterFit, [this]);
|
||
|
},
|
||
|
isHorizontal: function () {
|
||
|
return (
|
||
|
"top" === this.options.position ||
|
||
|
"bottom" === this.options.position
|
||
|
);
|
||
|
},
|
||
|
isFullWidth: function () {
|
||
|
return this.options.fullWidth;
|
||
|
},
|
||
|
getRightValue: function (t) {
|
||
|
if (o.isNullOrUndef(t)) return NaN;
|
||
|
if ("number" == typeof t && !isFinite(t)) return NaN;
|
||
|
if (t)
|
||
|
if (this.isHorizontal()) {
|
||
|
if (void 0 !== t.x) return this.getRightValue(t.x);
|
||
|
} else if (void 0 !== t.y) return this.getRightValue(t.y);
|
||
|
return t;
|
||
|
},
|
||
|
getLabelForIndex: o.noop,
|
||
|
getPixelForValue: o.noop,
|
||
|
getValueForPixel: o.noop,
|
||
|
getPixelForTick: function (t) {
|
||
|
var e = this,
|
||
|
i = e.options.offset;
|
||
|
if (e.isHorizontal()) {
|
||
|
var n =
|
||
|
(e.width - (e.paddingLeft + e.paddingRight)) /
|
||
|
Math.max(e._ticks.length - (i ? 0 : 1), 1),
|
||
|
a = n * t + e.paddingLeft;
|
||
|
i && (a += n / 2);
|
||
|
var o = e.left + Math.round(a);
|
||
|
return (o += e.isFullWidth() ? e.margins.left : 0);
|
||
|
}
|
||
|
var r = e.height - (e.paddingTop + e.paddingBottom);
|
||
|
return e.top + t * (r / (e._ticks.length - 1));
|
||
|
},
|
||
|
getPixelForDecimal: function (t) {
|
||
|
var e = this;
|
||
|
if (e.isHorizontal()) {
|
||
|
var i =
|
||
|
(e.width - (e.paddingLeft + e.paddingRight)) * t +
|
||
|
e.paddingLeft,
|
||
|
n = e.left + Math.round(i);
|
||
|
return (n += e.isFullWidth() ? e.margins.left : 0);
|
||
|
}
|
||
|
return e.top + t * e.height;
|
||
|
},
|
||
|
getBasePixel: function () {
|
||
|
return this.getPixelForValue(this.getBaseValue());
|
||
|
},
|
||
|
getBaseValue: function () {
|
||
|
var t = this.min,
|
||
|
e = this.max;
|
||
|
return this.beginAtZero
|
||
|
? 0
|
||
|
: t < 0 && e < 0
|
||
|
? e
|
||
|
: t > 0 && e > 0
|
||
|
? t
|
||
|
: 0;
|
||
|
},
|
||
|
_autoSkip: function (t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
a,
|
||
|
r = this,
|
||
|
s = r.isHorizontal(),
|
||
|
l = r.options.ticks.minor,
|
||
|
u = t.length,
|
||
|
d = o.toRadians(r.labelRotation),
|
||
|
c = Math.cos(d),
|
||
|
h = r.longestLabelWidth * c,
|
||
|
f = [];
|
||
|
for (
|
||
|
l.maxTicksLimit && (a = l.maxTicksLimit),
|
||
|
s &&
|
||
|
((e = !1),
|
||
|
(h + l.autoSkipPadding) * u >
|
||
|
r.width - (r.paddingLeft + r.paddingRight) &&
|
||
|
(e =
|
||
|
1 +
|
||
|
Math.floor(
|
||
|
((h + l.autoSkipPadding) * u) /
|
||
|
(r.width - (r.paddingLeft + r.paddingRight))
|
||
|
)),
|
||
|
a && u > a && (e = Math.max(e, Math.floor(u / a)))),
|
||
|
i = 0;
|
||
|
i < u;
|
||
|
i++
|
||
|
)
|
||
|
(n = t[i]),
|
||
|
((e > 1 && i % e > 0) || (i % e == 0 && i + e >= u)) &&
|
||
|
i !== u - 1 &&
|
||
|
delete n.label,
|
||
|
f.push(n);
|
||
|
return f;
|
||
|
},
|
||
|
draw: function (t) {
|
||
|
var e = this,
|
||
|
a = e.options;
|
||
|
if (a.display) {
|
||
|
var s = e.ctx,
|
||
|
u = n.global,
|
||
|
d = a.ticks.minor,
|
||
|
c = a.ticks.major || d,
|
||
|
h = a.gridLines,
|
||
|
f = a.scaleLabel,
|
||
|
g = 0 !== e.labelRotation,
|
||
|
p = e.isHorizontal(),
|
||
|
m = d.autoSkip ? e._autoSkip(e.getTicks()) : e.getTicks(),
|
||
|
v = o.valueOrDefault(d.fontColor, u.defaultFontColor),
|
||
|
b = i(d),
|
||
|
x = o.valueOrDefault(c.fontColor, u.defaultFontColor),
|
||
|
y = i(c),
|
||
|
k = h.drawTicks ? h.tickMarkLength : 0,
|
||
|
M = o.valueOrDefault(f.fontColor, u.defaultFontColor),
|
||
|
w = i(f),
|
||
|
S = o.options.toPadding(f.padding),
|
||
|
C = o.toRadians(e.labelRotation),
|
||
|
_ = [],
|
||
|
D = e.options.gridLines.lineWidth,
|
||
|
I = "right" === a.position ? e.right : e.right - D - k,
|
||
|
P = "right" === a.position ? e.right + k : e.right,
|
||
|
A =
|
||
|
"bottom" === a.position ? e.top + D : e.bottom - k - D,
|
||
|
T =
|
||
|
"bottom" === a.position ? e.top + D + k : e.bottom + D;
|
||
|
if (
|
||
|
(o.each(m, function (i, n) {
|
||
|
if (!o.isNullOrUndef(i.label)) {
|
||
|
var r,
|
||
|
s,
|
||
|
c,
|
||
|
f,
|
||
|
v,
|
||
|
b,
|
||
|
x,
|
||
|
y,
|
||
|
M,
|
||
|
w,
|
||
|
S,
|
||
|
F,
|
||
|
O,
|
||
|
R,
|
||
|
L = i.label;
|
||
|
n === e.zeroLineIndex &&
|
||
|
a.offset === h.offsetGridLines
|
||
|
? ((r = h.zeroLineWidth),
|
||
|
(s = h.zeroLineColor),
|
||
|
(c = h.zeroLineBorderDash),
|
||
|
(f = h.zeroLineBorderDashOffset))
|
||
|
: ((r = o.valueAtIndexOrDefault(h.lineWidth, n)),
|
||
|
(s = o.valueAtIndexOrDefault(h.color, n)),
|
||
|
(c = o.valueOrDefault(
|
||
|
h.borderDash,
|
||
|
u.borderDash
|
||
|
)),
|
||
|
(f = o.valueOrDefault(
|
||
|
h.borderDashOffset,
|
||
|
u.borderDashOffset
|
||
|
)));
|
||
|
var z = "middle",
|
||
|
B = "middle",
|
||
|
W = d.padding;
|
||
|
if (p) {
|
||
|
var N = k + W;
|
||
|
"bottom" === a.position
|
||
|
? ((B = g ? "middle" : "top"),
|
||
|
(z = g ? "right" : "center"),
|
||
|
(R = e.top + N))
|
||
|
: ((B = g ? "middle" : "bottom"),
|
||
|
(z = g ? "left" : "center"),
|
||
|
(R = e.bottom - N));
|
||
|
var V = l(e, n, h.offsetGridLines && m.length > 1);
|
||
|
V < e.left && (s = "rgba(0,0,0,0)"),
|
||
|
(V += o.aliasPixel(r)),
|
||
|
(O = e.getPixelForTick(n) + d.labelOffset),
|
||
|
(v = x = M = S = V),
|
||
|
(b = A),
|
||
|
(y = T),
|
||
|
(w = t.top),
|
||
|
(F = t.bottom + D);
|
||
|
} else {
|
||
|
var E,
|
||
|
H = "left" === a.position;
|
||
|
d.mirror
|
||
|
? ((z = H ? "left" : "right"), (E = W))
|
||
|
: ((z = H ? "right" : "left"), (E = k + W)),
|
||
|
(O = H ? e.right - E : e.left + E);
|
||
|
var j = l(e, n, h.offsetGridLines && m.length > 1);
|
||
|
j < e.top && (s = "rgba(0,0,0,0)"),
|
||
|
(j += o.aliasPixel(r)),
|
||
|
(R = e.getPixelForTick(n) + d.labelOffset),
|
||
|
(v = I),
|
||
|
(x = P),
|
||
|
(M = t.left),
|
||
|
(S = t.right + D),
|
||
|
(b = y = w = F = j);
|
||
|
}
|
||
|
_.push({
|
||
|
tx1: v,
|
||
|
ty1: b,
|
||
|
tx2: x,
|
||
|
ty2: y,
|
||
|
x1: M,
|
||
|
y1: w,
|
||
|
x2: S,
|
||
|
y2: F,
|
||
|
labelX: O,
|
||
|
labelY: R,
|
||
|
glWidth: r,
|
||
|
glColor: s,
|
||
|
glBorderDash: c,
|
||
|
glBorderDashOffset: f,
|
||
|
rotation: -1 * C,
|
||
|
label: L,
|
||
|
major: i.major,
|
||
|
textBaseline: B,
|
||
|
textAlign: z,
|
||
|
});
|
||
|
}
|
||
|
}),
|
||
|
o.each(_, function (t) {
|
||
|
if (
|
||
|
(h.display &&
|
||
|
(s.save(),
|
||
|
(s.lineWidth = t.glWidth),
|
||
|
(s.strokeStyle = t.glColor),
|
||
|
s.setLineDash &&
|
||
|
(s.setLineDash(t.glBorderDash),
|
||
|
(s.lineDashOffset = t.glBorderDashOffset)),
|
||
|
s.beginPath(),
|
||
|
h.drawTicks &&
|
||
|
(s.moveTo(t.tx1, t.ty1), s.lineTo(t.tx2, t.ty2)),
|
||
|
h.drawOnChartArea &&
|
||
|
(s.moveTo(t.x1, t.y1), s.lineTo(t.x2, t.y2)),
|
||
|
s.stroke(),
|
||
|
s.restore()),
|
||
|
d.display)
|
||
|
) {
|
||
|
s.save(),
|
||
|
s.translate(t.labelX, t.labelY),
|
||
|
s.rotate(t.rotation),
|
||
|
(s.font = t.major ? y.font : b.font),
|
||
|
(s.fillStyle = t.major ? x : v),
|
||
|
(s.textBaseline = t.textBaseline),
|
||
|
(s.textAlign = t.textAlign);
|
||
|
var i = t.label;
|
||
|
if (o.isArray(i))
|
||
|
for (
|
||
|
var n = i.length,
|
||
|
a = 1.5 * b.size,
|
||
|
r = e.isHorizontal() ? 0 : (-a * (n - 1)) / 2,
|
||
|
l = 0;
|
||
|
l < n;
|
||
|
++l
|
||
|
)
|
||
|
s.fillText("" + i[l], 0, r), (r += a);
|
||
|
else s.fillText(i, 0, 0);
|
||
|
s.restore();
|
||
|
}
|
||
|
}),
|
||
|
f.display)
|
||
|
) {
|
||
|
var F,
|
||
|
O,
|
||
|
R = 0,
|
||
|
L = r(f) / 2;
|
||
|
if (p)
|
||
|
(F = e.left + (e.right - e.left) / 2),
|
||
|
(O =
|
||
|
"bottom" === a.position
|
||
|
? e.bottom - L - S.bottom
|
||
|
: e.top + L + S.top);
|
||
|
else {
|
||
|
var z = "left" === a.position;
|
||
|
(F = z ? e.left + L + S.top : e.right - L - S.top),
|
||
|
(O = e.top + (e.bottom - e.top) / 2),
|
||
|
(R = z ? -0.5 * Math.PI : 0.5 * Math.PI);
|
||
|
}
|
||
|
s.save(),
|
||
|
s.translate(F, O),
|
||
|
s.rotate(R),
|
||
|
(s.textAlign = "center"),
|
||
|
(s.textBaseline = "middle"),
|
||
|
(s.fillStyle = M),
|
||
|
(s.font = w.font),
|
||
|
s.fillText(f.labelString, 0, 0),
|
||
|
s.restore();
|
||
|
}
|
||
|
if (h.drawBorder) {
|
||
|
(s.lineWidth = o.valueAtIndexOrDefault(h.lineWidth, 0)),
|
||
|
(s.strokeStyle = o.valueAtIndexOrDefault(h.color, 0));
|
||
|
var B = e.left,
|
||
|
W = e.right + D,
|
||
|
N = e.top,
|
||
|
V = e.bottom + D,
|
||
|
E = o.aliasPixel(s.lineWidth);
|
||
|
p
|
||
|
? ((N = V = "top" === a.position ? e.bottom : e.top),
|
||
|
(N += E),
|
||
|
(V += E))
|
||
|
: ((B = W = "left" === a.position ? e.right : e.left),
|
||
|
(B += E),
|
||
|
(W += E)),
|
||
|
s.beginPath(),
|
||
|
s.moveTo(B, N),
|
||
|
s.lineTo(W, V),
|
||
|
s.stroke();
|
||
|
}
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 26: 26, 34: 34, 45: 45 },
|
||
|
],
|
||
|
33: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(45),
|
||
|
o = t(30);
|
||
|
e.exports = function (t) {
|
||
|
t.scaleService = {
|
||
|
constructors: {},
|
||
|
defaults: {},
|
||
|
registerScaleType: function (t, e, i) {
|
||
|
(this.constructors[t] = e), (this.defaults[t] = a.clone(i));
|
||
|
},
|
||
|
getScaleConstructor: function (t) {
|
||
|
return this.constructors.hasOwnProperty(t)
|
||
|
? this.constructors[t]
|
||
|
: void 0;
|
||
|
},
|
||
|
getScaleDefaults: function (t) {
|
||
|
return this.defaults.hasOwnProperty(t)
|
||
|
? a.merge({}, [n.scale, this.defaults[t]])
|
||
|
: {};
|
||
|
},
|
||
|
updateScaleDefaults: function (t, e) {
|
||
|
this.defaults.hasOwnProperty(t) &&
|
||
|
(this.defaults[t] = a.extend(this.defaults[t], e));
|
||
|
},
|
||
|
addScalesToLayout: function (t) {
|
||
|
a.each(t.scales, function (e) {
|
||
|
(e.fullWidth = e.options.fullWidth),
|
||
|
(e.position = e.options.position),
|
||
|
(e.weight = e.options.weight),
|
||
|
o.addBox(t, e);
|
||
|
});
|
||
|
},
|
||
|
};
|
||
|
};
|
||
|
},
|
||
|
{ 25: 25, 30: 30, 45: 45 },
|
||
|
],
|
||
|
34: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45);
|
||
|
e.exports = {
|
||
|
formatters: {
|
||
|
values: function (t) {
|
||
|
return n.isArray(t) ? t : "" + t;
|
||
|
},
|
||
|
linear: function (t, e, i) {
|
||
|
var a = i.length > 3 ? i[2] - i[1] : i[1] - i[0];
|
||
|
Math.abs(a) > 1 &&
|
||
|
t !== Math.floor(t) &&
|
||
|
(a = t - Math.floor(t));
|
||
|
var o = n.log10(Math.abs(a)),
|
||
|
r = "";
|
||
|
if (0 !== t) {
|
||
|
var s = -1 * Math.floor(o);
|
||
|
(s = Math.max(Math.min(s, 20), 0)), (r = t.toFixed(s));
|
||
|
} else r = "0";
|
||
|
return r;
|
||
|
},
|
||
|
logarithmic: function (t, e, i) {
|
||
|
var a = t / Math.pow(10, Math.floor(n.log10(t)));
|
||
|
return 0 === t
|
||
|
? "0"
|
||
|
: 1 === a ||
|
||
|
2 === a ||
|
||
|
5 === a ||
|
||
|
0 === e ||
|
||
|
e === i.length - 1
|
||
|
? t.toExponential()
|
||
|
: "";
|
||
|
},
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{ 45: 45 },
|
||
|
],
|
||
|
35: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26),
|
||
|
o = t(45);
|
||
|
n._set("global", {
|
||
|
tooltips: {
|
||
|
enabled: !0,
|
||
|
custom: null,
|
||
|
mode: "nearest",
|
||
|
position: "average",
|
||
|
intersect: !0,
|
||
|
backgroundColor: "rgba(0,0,0,0.8)",
|
||
|
titleFontStyle: "bold",
|
||
|
titleSpacing: 2,
|
||
|
titleMarginBottom: 6,
|
||
|
titleFontColor: "#fff",
|
||
|
titleAlign: "left",
|
||
|
bodySpacing: 2,
|
||
|
bodyFontColor: "#fff",
|
||
|
bodyAlign: "left",
|
||
|
footerFontStyle: "bold",
|
||
|
footerSpacing: 2,
|
||
|
footerMarginTop: 6,
|
||
|
footerFontColor: "#fff",
|
||
|
footerAlign: "left",
|
||
|
yPadding: 6,
|
||
|
xPadding: 6,
|
||
|
caretPadding: 2,
|
||
|
caretSize: 5,
|
||
|
cornerRadius: 6,
|
||
|
multiKeyBackground: "#fff",
|
||
|
displayColors: !0,
|
||
|
borderColor: "rgba(0,0,0,0)",
|
||
|
borderWidth: 0,
|
||
|
callbacks: {
|
||
|
beforeTitle: o.noop,
|
||
|
title: function (t, e) {
|
||
|
var i = "",
|
||
|
n = e.labels,
|
||
|
a = n ? n.length : 0;
|
||
|
if (t.length > 0) {
|
||
|
var o = t[0];
|
||
|
o.xLabel
|
||
|
? (i = o.xLabel)
|
||
|
: a > 0 && o.index < a && (i = n[o.index]);
|
||
|
}
|
||
|
return i;
|
||
|
},
|
||
|
afterTitle: o.noop,
|
||
|
beforeBody: o.noop,
|
||
|
beforeLabel: o.noop,
|
||
|
label: function (t, e) {
|
||
|
var i = e.datasets[t.datasetIndex].label || "";
|
||
|
return i && (i += ": "), (i += t.yLabel);
|
||
|
},
|
||
|
labelColor: function (t, e) {
|
||
|
var i = e.getDatasetMeta(t.datasetIndex).data[t.index]._view;
|
||
|
return {
|
||
|
borderColor: i.borderColor,
|
||
|
backgroundColor: i.backgroundColor,
|
||
|
};
|
||
|
},
|
||
|
labelTextColor: function () {
|
||
|
return this._options.bodyFontColor;
|
||
|
},
|
||
|
afterLabel: o.noop,
|
||
|
afterBody: o.noop,
|
||
|
beforeFooter: o.noop,
|
||
|
footer: o.noop,
|
||
|
afterFooter: o.noop,
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = function (t) {
|
||
|
function e(t, e) {
|
||
|
var i = o.color(t);
|
||
|
return i.alpha(e * i.alpha()).rgbaString();
|
||
|
}
|
||
|
function i(t, e) {
|
||
|
return (
|
||
|
e &&
|
||
|
(o.isArray(e)
|
||
|
? Array.prototype.push.apply(t, e)
|
||
|
: t.push(e)),
|
||
|
t
|
||
|
);
|
||
|
}
|
||
|
function r(t) {
|
||
|
var e = n.global,
|
||
|
i = o.valueOrDefault;
|
||
|
return {
|
||
|
xPadding: t.xPadding,
|
||
|
yPadding: t.yPadding,
|
||
|
xAlign: t.xAlign,
|
||
|
yAlign: t.yAlign,
|
||
|
bodyFontColor: t.bodyFontColor,
|
||
|
_bodyFontFamily: i(t.bodyFontFamily, e.defaultFontFamily),
|
||
|
_bodyFontStyle: i(t.bodyFontStyle, e.defaultFontStyle),
|
||
|
_bodyAlign: t.bodyAlign,
|
||
|
bodyFontSize: i(t.bodyFontSize, e.defaultFontSize),
|
||
|
bodySpacing: t.bodySpacing,
|
||
|
titleFontColor: t.titleFontColor,
|
||
|
_titleFontFamily: i(t.titleFontFamily, e.defaultFontFamily),
|
||
|
_titleFontStyle: i(t.titleFontStyle, e.defaultFontStyle),
|
||
|
titleFontSize: i(t.titleFontSize, e.defaultFontSize),
|
||
|
_titleAlign: t.titleAlign,
|
||
|
titleSpacing: t.titleSpacing,
|
||
|
titleMarginBottom: t.titleMarginBottom,
|
||
|
footerFontColor: t.footerFontColor,
|
||
|
_footerFontFamily: i(t.footerFontFamily, e.defaultFontFamily),
|
||
|
_footerFontStyle: i(t.footerFontStyle, e.defaultFontStyle),
|
||
|
footerFontSize: i(t.footerFontSize, e.defaultFontSize),
|
||
|
_footerAlign: t.footerAlign,
|
||
|
footerSpacing: t.footerSpacing,
|
||
|
footerMarginTop: t.footerMarginTop,
|
||
|
caretSize: t.caretSize,
|
||
|
cornerRadius: t.cornerRadius,
|
||
|
backgroundColor: t.backgroundColor,
|
||
|
opacity: 0,
|
||
|
legendColorBackground: t.multiKeyBackground,
|
||
|
displayColors: t.displayColors,
|
||
|
borderColor: t.borderColor,
|
||
|
borderWidth: t.borderWidth,
|
||
|
};
|
||
|
}
|
||
|
(t.Tooltip = a.extend({
|
||
|
initialize: function () {
|
||
|
(this._model = r(this._options)), (this._lastActive = []);
|
||
|
},
|
||
|
getTitle: function () {
|
||
|
var t = this._options.callbacks,
|
||
|
e = t.beforeTitle.apply(this, arguments),
|
||
|
n = t.title.apply(this, arguments),
|
||
|
a = t.afterTitle.apply(this, arguments),
|
||
|
o = [];
|
||
|
return (o = i((o = i((o = i(o, e)), n)), a));
|
||
|
},
|
||
|
getBeforeBody: function () {
|
||
|
var t = this._options.callbacks.beforeBody.apply(
|
||
|
this,
|
||
|
arguments
|
||
|
);
|
||
|
return o.isArray(t) ? t : void 0 !== t ? [t] : [];
|
||
|
},
|
||
|
getBody: function (t, e) {
|
||
|
var n = this,
|
||
|
a = n._options.callbacks,
|
||
|
r = [];
|
||
|
return (
|
||
|
o.each(t, function (t) {
|
||
|
var o = { before: [], lines: [], after: [] };
|
||
|
i(o.before, a.beforeLabel.call(n, t, e)),
|
||
|
i(o.lines, a.label.call(n, t, e)),
|
||
|
i(o.after, a.afterLabel.call(n, t, e)),
|
||
|
r.push(o);
|
||
|
}),
|
||
|
r
|
||
|
);
|
||
|
},
|
||
|
getAfterBody: function () {
|
||
|
var t = this._options.callbacks.afterBody.apply(
|
||
|
this,
|
||
|
arguments
|
||
|
);
|
||
|
return o.isArray(t) ? t : void 0 !== t ? [t] : [];
|
||
|
},
|
||
|
getFooter: function () {
|
||
|
var t = this._options.callbacks,
|
||
|
e = t.beforeFooter.apply(this, arguments),
|
||
|
n = t.footer.apply(this, arguments),
|
||
|
a = t.afterFooter.apply(this, arguments),
|
||
|
o = [];
|
||
|
return (o = i((o = i((o = i(o, e)), n)), a));
|
||
|
},
|
||
|
update: function (e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
s,
|
||
|
l,
|
||
|
u,
|
||
|
d,
|
||
|
c,
|
||
|
h,
|
||
|
f,
|
||
|
g,
|
||
|
p,
|
||
|
m,
|
||
|
v,
|
||
|
b,
|
||
|
x,
|
||
|
y,
|
||
|
k,
|
||
|
M,
|
||
|
w,
|
||
|
S = this,
|
||
|
C = S._options,
|
||
|
_ = S._model,
|
||
|
D = (S._model = r(C)),
|
||
|
I = S._active,
|
||
|
P = S._data,
|
||
|
A = { xAlign: _.xAlign, yAlign: _.yAlign },
|
||
|
T = { x: _.x, y: _.y },
|
||
|
F = { width: _.width, height: _.height },
|
||
|
O = { x: _.caretX, y: _.caretY };
|
||
|
if (I.length) {
|
||
|
D.opacity = 1;
|
||
|
var R = [],
|
||
|
L = [];
|
||
|
O = t.Tooltip.positioners[C.position].call(
|
||
|
S,
|
||
|
I,
|
||
|
S._eventPosition
|
||
|
);
|
||
|
var z = [];
|
||
|
for (i = 0, n = I.length; i < n; ++i)
|
||
|
z.push(
|
||
|
((x = I[i]),
|
||
|
(y = void 0),
|
||
|
(k = void 0),
|
||
|
void 0,
|
||
|
void 0,
|
||
|
(y = x._xScale),
|
||
|
(k = x._yScale || x._scale),
|
||
|
(M = x._index),
|
||
|
(w = x._datasetIndex),
|
||
|
{
|
||
|
xLabel: y ? y.getLabelForIndex(M, w) : "",
|
||
|
yLabel: k ? k.getLabelForIndex(M, w) : "",
|
||
|
index: M,
|
||
|
datasetIndex: w,
|
||
|
x: x._model.x,
|
||
|
y: x._model.y,
|
||
|
})
|
||
|
);
|
||
|
C.filter &&
|
||
|
(z = z.filter(function (t) {
|
||
|
return C.filter(t, P);
|
||
|
})),
|
||
|
C.itemSort &&
|
||
|
(z = z.sort(function (t, e) {
|
||
|
return C.itemSort(t, e, P);
|
||
|
})),
|
||
|
o.each(z, function (t) {
|
||
|
R.push(C.callbacks.labelColor.call(S, t, S._chart)),
|
||
|
L.push(
|
||
|
C.callbacks.labelTextColor.call(S, t, S._chart)
|
||
|
);
|
||
|
}),
|
||
|
(D.title = S.getTitle(z, P)),
|
||
|
(D.beforeBody = S.getBeforeBody(z, P)),
|
||
|
(D.body = S.getBody(z, P)),
|
||
|
(D.afterBody = S.getAfterBody(z, P)),
|
||
|
(D.footer = S.getFooter(z, P)),
|
||
|
(D.x = Math.round(O.x)),
|
||
|
(D.y = Math.round(O.y)),
|
||
|
(D.caretPadding = C.caretPadding),
|
||
|
(D.labelColors = R),
|
||
|
(D.labelTextColors = L),
|
||
|
(D.dataPoints = z),
|
||
|
(A = (function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s = t._model,
|
||
|
l = t._chart,
|
||
|
u = t._chart.chartArea,
|
||
|
d = "center",
|
||
|
c = "center";
|
||
|
s.y < e.height
|
||
|
? (c = "top")
|
||
|
: s.y > l.height - e.height && (c = "bottom");
|
||
|
var h = (u.left + u.right) / 2,
|
||
|
f = (u.top + u.bottom) / 2;
|
||
|
"center" === c
|
||
|
? ((i = function (t) {
|
||
|
return t <= h;
|
||
|
}),
|
||
|
(n = function (t) {
|
||
|
return t > h;
|
||
|
}))
|
||
|
: ((i = function (t) {
|
||
|
return t <= e.width / 2;
|
||
|
}),
|
||
|
(n = function (t) {
|
||
|
return t >= l.width - e.width / 2;
|
||
|
})),
|
||
|
(a = function (t) {
|
||
|
return (
|
||
|
t + e.width + s.caretSize + s.caretPadding >
|
||
|
l.width
|
||
|
);
|
||
|
}),
|
||
|
(o = function (t) {
|
||
|
return (
|
||
|
t - e.width - s.caretSize - s.caretPadding < 0
|
||
|
);
|
||
|
}),
|
||
|
(r = function (t) {
|
||
|
return t <= f ? "top" : "bottom";
|
||
|
}),
|
||
|
i(s.x)
|
||
|
? ((d = "left"),
|
||
|
a(s.x) && ((d = "center"), (c = r(s.y))))
|
||
|
: n(s.x) &&
|
||
|
((d = "right"),
|
||
|
o(s.x) && ((d = "center"), (c = r(s.y))));
|
||
|
var g = t._options;
|
||
|
return {
|
||
|
xAlign: g.xAlign ? g.xAlign : d,
|
||
|
yAlign: g.yAlign ? g.yAlign : c,
|
||
|
};
|
||
|
})(
|
||
|
this,
|
||
|
(F = (function (t, e) {
|
||
|
var i = t._chart.ctx,
|
||
|
n = 2 * e.yPadding,
|
||
|
a = 0,
|
||
|
r = e.body,
|
||
|
s = r.reduce(function (t, e) {
|
||
|
return (
|
||
|
t +
|
||
|
e.before.length +
|
||
|
e.lines.length +
|
||
|
e.after.length
|
||
|
);
|
||
|
}, 0);
|
||
|
s += e.beforeBody.length + e.afterBody.length;
|
||
|
var l = e.title.length,
|
||
|
u = e.footer.length,
|
||
|
d = e.titleFontSize,
|
||
|
c = e.bodyFontSize,
|
||
|
h = e.footerFontSize;
|
||
|
(n += l * d),
|
||
|
(n += l ? (l - 1) * e.titleSpacing : 0),
|
||
|
(n += l ? e.titleMarginBottom : 0),
|
||
|
(n += s * c),
|
||
|
(n += s ? (s - 1) * e.bodySpacing : 0),
|
||
|
(n += u ? e.footerMarginTop : 0),
|
||
|
(n += u * h),
|
||
|
(n += u ? (u - 1) * e.footerSpacing : 0);
|
||
|
var f = 0,
|
||
|
g = function (t) {
|
||
|
a = Math.max(a, i.measureText(t).width + f);
|
||
|
};
|
||
|
return (
|
||
|
(i.font = o.fontString(
|
||
|
d,
|
||
|
e._titleFontStyle,
|
||
|
e._titleFontFamily
|
||
|
)),
|
||
|
o.each(e.title, g),
|
||
|
(i.font = o.fontString(
|
||
|
c,
|
||
|
e._bodyFontStyle,
|
||
|
e._bodyFontFamily
|
||
|
)),
|
||
|
o.each(e.beforeBody.concat(e.afterBody), g),
|
||
|
(f = e.displayColors ? c + 2 : 0),
|
||
|
o.each(r, function (t) {
|
||
|
o.each(t.before, g),
|
||
|
o.each(t.lines, g),
|
||
|
o.each(t.after, g);
|
||
|
}),
|
||
|
(f = 0),
|
||
|
(i.font = o.fontString(
|
||
|
h,
|
||
|
e._footerFontStyle,
|
||
|
e._footerFontFamily
|
||
|
)),
|
||
|
o.each(e.footer, g),
|
||
|
{ width: (a += 2 * e.xPadding), height: n }
|
||
|
);
|
||
|
})(this, D))
|
||
|
)),
|
||
|
(a = D),
|
||
|
(s = F),
|
||
|
(l = A),
|
||
|
(u = S._chart),
|
||
|
(d = a.x),
|
||
|
(c = a.y),
|
||
|
(h = a.caretSize),
|
||
|
(f = a.caretPadding),
|
||
|
(g = a.cornerRadius),
|
||
|
(p = l.xAlign),
|
||
|
(m = l.yAlign),
|
||
|
(v = h + f),
|
||
|
(b = g + f),
|
||
|
"right" === p
|
||
|
? (d -= s.width)
|
||
|
: "center" === p &&
|
||
|
((d -= s.width / 2) + s.width > u.width &&
|
||
|
(d = u.width - s.width),
|
||
|
d < 0 && (d = 0)),
|
||
|
"top" === m
|
||
|
? (c += v)
|
||
|
: (c -= "bottom" === m ? s.height + v : s.height / 2),
|
||
|
"center" === m
|
||
|
? "left" === p
|
||
|
? (d += v)
|
||
|
: "right" === p && (d -= v)
|
||
|
: "left" === p
|
||
|
? (d -= b)
|
||
|
: "right" === p && (d += b),
|
||
|
(T = { x: d, y: c });
|
||
|
} else D.opacity = 0;
|
||
|
return (
|
||
|
(D.xAlign = A.xAlign),
|
||
|
(D.yAlign = A.yAlign),
|
||
|
(D.x = T.x),
|
||
|
(D.y = T.y),
|
||
|
(D.width = F.width),
|
||
|
(D.height = F.height),
|
||
|
(D.caretX = O.x),
|
||
|
(D.caretY = O.y),
|
||
|
(S._model = D),
|
||
|
e && C.custom && C.custom.call(S, D),
|
||
|
S
|
||
|
);
|
||
|
},
|
||
|
drawCaret: function (t, e) {
|
||
|
var i = this._chart.ctx,
|
||
|
n = this._view,
|
||
|
a = this.getCaretPosition(t, e, n);
|
||
|
i.lineTo(a.x1, a.y1),
|
||
|
i.lineTo(a.x2, a.y2),
|
||
|
i.lineTo(a.x3, a.y3);
|
||
|
},
|
||
|
getCaretPosition: function (t, e, i) {
|
||
|
var n,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s,
|
||
|
l,
|
||
|
u = i.caretSize,
|
||
|
d = i.cornerRadius,
|
||
|
c = i.xAlign,
|
||
|
h = i.yAlign,
|
||
|
f = t.x,
|
||
|
g = t.y,
|
||
|
p = e.width,
|
||
|
m = e.height;
|
||
|
if ("center" === h)
|
||
|
(s = g + m / 2),
|
||
|
"left" === c
|
||
|
? ((a = (n = f) - u), (o = n), (r = s + u), (l = s - u))
|
||
|
: ((a = (n = f + p) + u),
|
||
|
(o = n),
|
||
|
(r = s - u),
|
||
|
(l = s + u));
|
||
|
else if (
|
||
|
("left" === c
|
||
|
? ((n = (a = f + d + u) - u), (o = a + u))
|
||
|
: "right" === c
|
||
|
? ((n = (a = f + p - d - u) - u), (o = a + u))
|
||
|
: ((n = (a = i.caretX) - u), (o = a + u)),
|
||
|
"top" === h)
|
||
|
)
|
||
|
(s = (r = g) - u), (l = r);
|
||
|
else {
|
||
|
(s = (r = g + m) + u), (l = r);
|
||
|
var v = o;
|
||
|
(o = n), (n = v);
|
||
|
}
|
||
|
return { x1: n, x2: a, x3: o, y1: r, y2: s, y3: l };
|
||
|
},
|
||
|
drawTitle: function (t, i, n, a) {
|
||
|
var r = i.title;
|
||
|
if (r.length) {
|
||
|
(n.textAlign = i._titleAlign), (n.textBaseline = "top");
|
||
|
var s,
|
||
|
l,
|
||
|
u = i.titleFontSize,
|
||
|
d = i.titleSpacing;
|
||
|
for (
|
||
|
n.fillStyle = e(i.titleFontColor, a),
|
||
|
n.font = o.fontString(
|
||
|
u,
|
||
|
i._titleFontStyle,
|
||
|
i._titleFontFamily
|
||
|
),
|
||
|
s = 0,
|
||
|
l = r.length;
|
||
|
s < l;
|
||
|
++s
|
||
|
)
|
||
|
n.fillText(r[s], t.x, t.y),
|
||
|
(t.y += u + d),
|
||
|
s + 1 === r.length && (t.y += i.titleMarginBottom - d);
|
||
|
}
|
||
|
},
|
||
|
drawBody: function (t, i, n, a) {
|
||
|
var r = i.bodyFontSize,
|
||
|
s = i.bodySpacing,
|
||
|
l = i.body;
|
||
|
(n.textAlign = i._bodyAlign),
|
||
|
(n.textBaseline = "top"),
|
||
|
(n.font = o.fontString(
|
||
|
r,
|
||
|
i._bodyFontStyle,
|
||
|
i._bodyFontFamily
|
||
|
));
|
||
|
var u = 0,
|
||
|
d = function (e) {
|
||
|
n.fillText(e, t.x + u, t.y), (t.y += r + s);
|
||
|
};
|
||
|
(n.fillStyle = e(i.bodyFontColor, a)),
|
||
|
o.each(i.beforeBody, d);
|
||
|
var c = i.displayColors;
|
||
|
(u = c ? r + 2 : 0),
|
||
|
o.each(l, function (s, l) {
|
||
|
var u = e(i.labelTextColors[l], a);
|
||
|
(n.fillStyle = u),
|
||
|
o.each(s.before, d),
|
||
|
o.each(s.lines, function (o) {
|
||
|
c &&
|
||
|
((n.fillStyle = e(i.legendColorBackground, a)),
|
||
|
n.fillRect(t.x, t.y, r, r),
|
||
|
(n.lineWidth = 1),
|
||
|
(n.strokeStyle = e(
|
||
|
i.labelColors[l].borderColor,
|
||
|
a
|
||
|
)),
|
||
|
n.strokeRect(t.x, t.y, r, r),
|
||
|
(n.fillStyle = e(
|
||
|
i.labelColors[l].backgroundColor,
|
||
|
a
|
||
|
)),
|
||
|
n.fillRect(t.x + 1, t.y + 1, r - 2, r - 2),
|
||
|
(n.fillStyle = u)),
|
||
|
d(o);
|
||
|
}),
|
||
|
o.each(s.after, d);
|
||
|
}),
|
||
|
(u = 0),
|
||
|
o.each(i.afterBody, d),
|
||
|
(t.y -= s);
|
||
|
},
|
||
|
drawFooter: function (t, i, n, a) {
|
||
|
var r = i.footer;
|
||
|
r.length &&
|
||
|
((t.y += i.footerMarginTop),
|
||
|
(n.textAlign = i._footerAlign),
|
||
|
(n.textBaseline = "top"),
|
||
|
(n.fillStyle = e(i.footerFontColor, a)),
|
||
|
(n.font = o.fontString(
|
||
|
i.footerFontSize,
|
||
|
i._footerFontStyle,
|
||
|
i._footerFontFamily
|
||
|
)),
|
||
|
o.each(r, function (e) {
|
||
|
n.fillText(e, t.x, t.y),
|
||
|
(t.y += i.footerFontSize + i.footerSpacing);
|
||
|
}));
|
||
|
},
|
||
|
drawBackground: function (t, i, n, a, o) {
|
||
|
(n.fillStyle = e(i.backgroundColor, o)),
|
||
|
(n.strokeStyle = e(i.borderColor, o)),
|
||
|
(n.lineWidth = i.borderWidth);
|
||
|
var r = i.xAlign,
|
||
|
s = i.yAlign,
|
||
|
l = t.x,
|
||
|
u = t.y,
|
||
|
d = a.width,
|
||
|
c = a.height,
|
||
|
h = i.cornerRadius;
|
||
|
n.beginPath(),
|
||
|
n.moveTo(l + h, u),
|
||
|
"top" === s && this.drawCaret(t, a),
|
||
|
n.lineTo(l + d - h, u),
|
||
|
n.quadraticCurveTo(l + d, u, l + d, u + h),
|
||
|
"center" === s && "right" === r && this.drawCaret(t, a),
|
||
|
n.lineTo(l + d, u + c - h),
|
||
|
n.quadraticCurveTo(l + d, u + c, l + d - h, u + c),
|
||
|
"bottom" === s && this.drawCaret(t, a),
|
||
|
n.lineTo(l + h, u + c),
|
||
|
n.quadraticCurveTo(l, u + c, l, u + c - h),
|
||
|
"center" === s && "left" === r && this.drawCaret(t, a),
|
||
|
n.lineTo(l, u + h),
|
||
|
n.quadraticCurveTo(l, u, l + h, u),
|
||
|
n.closePath(),
|
||
|
n.fill(),
|
||
|
i.borderWidth > 0 && n.stroke();
|
||
|
},
|
||
|
draw: function () {
|
||
|
var t = this._chart.ctx,
|
||
|
e = this._view;
|
||
|
if (0 !== e.opacity) {
|
||
|
var i = { width: e.width, height: e.height },
|
||
|
n = { x: e.x, y: e.y },
|
||
|
a = Math.abs(e.opacity < 0.001) ? 0 : e.opacity,
|
||
|
o =
|
||
|
e.title.length ||
|
||
|
e.beforeBody.length ||
|
||
|
e.body.length ||
|
||
|
e.afterBody.length ||
|
||
|
e.footer.length;
|
||
|
this._options.enabled &&
|
||
|
o &&
|
||
|
(this.drawBackground(n, e, t, i, a),
|
||
|
(n.x += e.xPadding),
|
||
|
(n.y += e.yPadding),
|
||
|
this.drawTitle(n, e, t, a),
|
||
|
this.drawBody(n, e, t, a),
|
||
|
this.drawFooter(n, e, t, a));
|
||
|
}
|
||
|
},
|
||
|
handleEvent: function (t) {
|
||
|
var e,
|
||
|
i = this,
|
||
|
n = i._options;
|
||
|
return (
|
||
|
(i._lastActive = i._lastActive || []),
|
||
|
"mouseout" === t.type
|
||
|
? (i._active = [])
|
||
|
: (i._active = i._chart.getElementsAtEventForMode(
|
||
|
t,
|
||
|
n.mode,
|
||
|
n
|
||
|
)),
|
||
|
(e = !o.arrayEquals(i._active, i._lastActive)) &&
|
||
|
((i._lastActive = i._active),
|
||
|
(n.enabled || n.custom) &&
|
||
|
((i._eventPosition = { x: t.x, y: t.y }),
|
||
|
i.update(!0),
|
||
|
i.pivot())),
|
||
|
e
|
||
|
);
|
||
|
},
|
||
|
})),
|
||
|
(t.Tooltip.positioners = {
|
||
|
average: function (t) {
|
||
|
if (!t.length) return !1;
|
||
|
var e,
|
||
|
i,
|
||
|
n = 0,
|
||
|
a = 0,
|
||
|
o = 0;
|
||
|
for (e = 0, i = t.length; e < i; ++e) {
|
||
|
var r = t[e];
|
||
|
if (r && r.hasValue()) {
|
||
|
var s = r.tooltipPosition();
|
||
|
(n += s.x), (a += s.y), ++o;
|
||
|
}
|
||
|
}
|
||
|
return { x: Math.round(n / o), y: Math.round(a / o) };
|
||
|
},
|
||
|
nearest: function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
r = e.x,
|
||
|
s = e.y,
|
||
|
l = Number.POSITIVE_INFINITY;
|
||
|
for (i = 0, n = t.length; i < n; ++i) {
|
||
|
var u = t[i];
|
||
|
if (u && u.hasValue()) {
|
||
|
var d = u.getCenterPoint(),
|
||
|
c = o.distanceBetweenPoints(e, d);
|
||
|
c < l && ((l = c), (a = u));
|
||
|
}
|
||
|
}
|
||
|
if (a) {
|
||
|
var h = a.tooltipPosition();
|
||
|
(r = h.x), (s = h.y);
|
||
|
}
|
||
|
return { x: r, y: s };
|
||
|
},
|
||
|
});
|
||
|
});
|
||
|
},
|
||
|
{ 25: 25, 26: 26, 45: 45 },
|
||
|
],
|
||
|
36: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26),
|
||
|
o = t(45);
|
||
|
n._set("global", {
|
||
|
elements: {
|
||
|
arc: {
|
||
|
backgroundColor: n.global.defaultColor,
|
||
|
borderColor: "#fff",
|
||
|
borderWidth: 2,
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = a.extend({
|
||
|
inLabelRange: function (t) {
|
||
|
var e = this._view;
|
||
|
return (
|
||
|
!!e &&
|
||
|
Math.pow(t - e.x, 2) < Math.pow(e.radius + e.hoverRadius, 2)
|
||
|
);
|
||
|
},
|
||
|
inRange: function (t, e) {
|
||
|
var i = this._view;
|
||
|
if (i) {
|
||
|
for (
|
||
|
var n = o.getAngleFromPoint(i, { x: t, y: e }),
|
||
|
a = n.angle,
|
||
|
r = n.distance,
|
||
|
s = i.startAngle,
|
||
|
l = i.endAngle;
|
||
|
l < s;
|
||
|
|
||
|
)
|
||
|
l += 2 * Math.PI;
|
||
|
for (; a > l; ) a -= 2 * Math.PI;
|
||
|
for (; a < s; ) a += 2 * Math.PI;
|
||
|
var u = a >= s && a <= l,
|
||
|
d = r >= i.innerRadius && r <= i.outerRadius;
|
||
|
return u && d;
|
||
|
}
|
||
|
return !1;
|
||
|
},
|
||
|
getCenterPoint: function () {
|
||
|
var t = this._view,
|
||
|
e = (t.startAngle + t.endAngle) / 2,
|
||
|
i = (t.innerRadius + t.outerRadius) / 2;
|
||
|
return { x: t.x + Math.cos(e) * i, y: t.y + Math.sin(e) * i };
|
||
|
},
|
||
|
getArea: function () {
|
||
|
var t = this._view;
|
||
|
return (
|
||
|
Math.PI *
|
||
|
((t.endAngle - t.startAngle) / (2 * Math.PI)) *
|
||
|
(Math.pow(t.outerRadius, 2) - Math.pow(t.innerRadius, 2))
|
||
|
);
|
||
|
},
|
||
|
tooltipPosition: function () {
|
||
|
var t = this._view,
|
||
|
e = t.startAngle + (t.endAngle - t.startAngle) / 2,
|
||
|
i = (t.outerRadius - t.innerRadius) / 2 + t.innerRadius;
|
||
|
return { x: t.x + Math.cos(e) * i, y: t.y + Math.sin(e) * i };
|
||
|
},
|
||
|
draw: function () {
|
||
|
var t = this._chart.ctx,
|
||
|
e = this._view,
|
||
|
i = e.startAngle,
|
||
|
n = e.endAngle;
|
||
|
t.beginPath(),
|
||
|
t.arc(e.x, e.y, e.outerRadius, i, n),
|
||
|
t.arc(e.x, e.y, e.innerRadius, n, i, !0),
|
||
|
t.closePath(),
|
||
|
(t.strokeStyle = e.borderColor),
|
||
|
(t.lineWidth = e.borderWidth),
|
||
|
(t.fillStyle = e.backgroundColor),
|
||
|
t.fill(),
|
||
|
(t.lineJoin = "bevel"),
|
||
|
e.borderWidth && t.stroke();
|
||
|
},
|
||
|
}));
|
||
|
},
|
||
|
{ 25: 25, 26: 26, 45: 45 },
|
||
|
],
|
||
|
37: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26),
|
||
|
o = t(45),
|
||
|
r = n.global;
|
||
|
n._set("global", {
|
||
|
elements: {
|
||
|
line: {
|
||
|
tension: 0.4,
|
||
|
backgroundColor: r.defaultColor,
|
||
|
borderWidth: 3,
|
||
|
borderColor: r.defaultColor,
|
||
|
borderCapStyle: "butt",
|
||
|
borderDash: [],
|
||
|
borderDashOffset: 0,
|
||
|
borderJoinStyle: "miter",
|
||
|
capBezierPoints: !0,
|
||
|
fill: !0,
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = a.extend({
|
||
|
draw: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i,
|
||
|
n,
|
||
|
a = this._view,
|
||
|
s = this._chart.ctx,
|
||
|
l = a.spanGaps,
|
||
|
u = this._children.slice(),
|
||
|
d = r.elements.line,
|
||
|
c = -1;
|
||
|
for (
|
||
|
this._loop && u.length && u.push(u[0]),
|
||
|
s.save(),
|
||
|
s.lineCap = a.borderCapStyle || d.borderCapStyle,
|
||
|
s.setLineDash &&
|
||
|
s.setLineDash(a.borderDash || d.borderDash),
|
||
|
s.lineDashOffset = a.borderDashOffset || d.borderDashOffset,
|
||
|
s.lineJoin = a.borderJoinStyle || d.borderJoinStyle,
|
||
|
s.lineWidth = a.borderWidth || d.borderWidth,
|
||
|
s.strokeStyle = a.borderColor || r.defaultColor,
|
||
|
s.beginPath(),
|
||
|
c = -1,
|
||
|
t = 0;
|
||
|
t < u.length;
|
||
|
++t
|
||
|
)
|
||
|
(e = u[t]),
|
||
|
(i = o.previousItem(u, t)),
|
||
|
(n = e._view),
|
||
|
0 === t
|
||
|
? n.skip || (s.moveTo(n.x, n.y), (c = t))
|
||
|
: ((i = -1 === c ? i : u[c]),
|
||
|
n.skip ||
|
||
|
((c !== t - 1 && !l) || -1 === c
|
||
|
? s.moveTo(n.x, n.y)
|
||
|
: o.canvas.lineTo(s, i._view, e._view),
|
||
|
(c = t)));
|
||
|
s.stroke(), s.restore();
|
||
|
},
|
||
|
}));
|
||
|
},
|
||
|
{ 25: 25, 26: 26, 45: 45 },
|
||
|
],
|
||
|
38: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26),
|
||
|
o = t(45),
|
||
|
r = n.global.defaultColor;
|
||
|
function s(t) {
|
||
|
var e = this._view;
|
||
|
return !!e && Math.abs(t - e.x) < e.radius + e.hitRadius;
|
||
|
}
|
||
|
n._set("global", {
|
||
|
elements: {
|
||
|
point: {
|
||
|
radius: 3,
|
||
|
pointStyle: "circle",
|
||
|
backgroundColor: r,
|
||
|
borderColor: r,
|
||
|
borderWidth: 1,
|
||
|
hitRadius: 1,
|
||
|
hoverRadius: 4,
|
||
|
hoverBorderWidth: 1,
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = a.extend({
|
||
|
inRange: function (t, e) {
|
||
|
var i = this._view;
|
||
|
return (
|
||
|
!!i &&
|
||
|
Math.pow(t - i.x, 2) + Math.pow(e - i.y, 2) <
|
||
|
Math.pow(i.hitRadius + i.radius, 2)
|
||
|
);
|
||
|
},
|
||
|
inLabelRange: s,
|
||
|
inXRange: s,
|
||
|
inYRange: function (t) {
|
||
|
var e = this._view;
|
||
|
return !!e && Math.abs(t - e.y) < e.radius + e.hitRadius;
|
||
|
},
|
||
|
getCenterPoint: function () {
|
||
|
var t = this._view;
|
||
|
return { x: t.x, y: t.y };
|
||
|
},
|
||
|
getArea: function () {
|
||
|
return Math.PI * Math.pow(this._view.radius, 2);
|
||
|
},
|
||
|
tooltipPosition: function () {
|
||
|
var t = this._view;
|
||
|
return { x: t.x, y: t.y, padding: t.radius + t.borderWidth };
|
||
|
},
|
||
|
draw: function (t) {
|
||
|
var e = this._view,
|
||
|
i = this._model,
|
||
|
a = this._chart.ctx,
|
||
|
s = e.pointStyle,
|
||
|
l = e.radius,
|
||
|
u = e.x,
|
||
|
d = e.y,
|
||
|
c = o.color,
|
||
|
h = 0;
|
||
|
e.skip ||
|
||
|
((a.strokeStyle = e.borderColor || r),
|
||
|
(a.lineWidth = o.valueOrDefault(
|
||
|
e.borderWidth,
|
||
|
n.global.elements.point.borderWidth
|
||
|
)),
|
||
|
(a.fillStyle = e.backgroundColor || r),
|
||
|
void 0 !== t &&
|
||
|
(i.x < t.left ||
|
||
|
1.01 * t.right < i.x ||
|
||
|
i.y < t.top ||
|
||
|
1.01 * t.bottom < i.y) &&
|
||
|
(i.x < t.left
|
||
|
? (h = (u - i.x) / (t.left - i.x))
|
||
|
: 1.01 * t.right < i.x
|
||
|
? (h = (i.x - u) / (i.x - t.right))
|
||
|
: i.y < t.top
|
||
|
? (h = (d - i.y) / (t.top - i.y))
|
||
|
: 1.01 * t.bottom < i.y &&
|
||
|
(h = (i.y - d) / (i.y - t.bottom)),
|
||
|
(h = Math.round(100 * h) / 100),
|
||
|
(a.strokeStyle = c(a.strokeStyle).alpha(h).rgbString()),
|
||
|
(a.fillStyle = c(a.fillStyle).alpha(h).rgbString())),
|
||
|
o.canvas.drawPoint(a, s, l, u, d));
|
||
|
},
|
||
|
}));
|
||
|
},
|
||
|
{ 25: 25, 26: 26, 45: 45 },
|
||
|
],
|
||
|
39: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26);
|
||
|
function o(t) {
|
||
|
return void 0 !== t._view.width;
|
||
|
}
|
||
|
function r(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
a,
|
||
|
r = t._view;
|
||
|
if (o(t)) {
|
||
|
var s = r.width / 2;
|
||
|
(e = r.x - s),
|
||
|
(i = r.x + s),
|
||
|
(n = Math.min(r.y, r.base)),
|
||
|
(a = Math.max(r.y, r.base));
|
||
|
} else {
|
||
|
var l = r.height / 2;
|
||
|
(e = Math.min(r.x, r.base)),
|
||
|
(i = Math.max(r.x, r.base)),
|
||
|
(n = r.y - l),
|
||
|
(a = r.y + l);
|
||
|
}
|
||
|
return { left: e, top: n, right: i, bottom: a };
|
||
|
}
|
||
|
n._set("global", {
|
||
|
elements: {
|
||
|
rectangle: {
|
||
|
backgroundColor: n.global.defaultColor,
|
||
|
borderColor: n.global.defaultColor,
|
||
|
borderSkipped: "bottom",
|
||
|
borderWidth: 0,
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(e.exports = a.extend({
|
||
|
draw: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i,
|
||
|
n,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s = this._chart.ctx,
|
||
|
l = this._view,
|
||
|
u = l.borderWidth;
|
||
|
if (
|
||
|
(l.horizontal
|
||
|
? ((t = l.base),
|
||
|
(e = l.x),
|
||
|
(i = l.y - l.height / 2),
|
||
|
(n = l.y + l.height / 2),
|
||
|
(a = e > t ? 1 : -1),
|
||
|
(o = 1),
|
||
|
(r = l.borderSkipped || "left"))
|
||
|
: ((t = l.x - l.width / 2),
|
||
|
(e = l.x + l.width / 2),
|
||
|
(i = l.y),
|
||
|
(a = 1),
|
||
|
(o = (n = l.base) > i ? 1 : -1),
|
||
|
(r = l.borderSkipped || "bottom")),
|
||
|
u)
|
||
|
) {
|
||
|
var d = Math.min(Math.abs(t - e), Math.abs(i - n)),
|
||
|
c = (u = u > d ? d : u) / 2,
|
||
|
h = t + ("left" !== r ? c * a : 0),
|
||
|
f = e + ("right" !== r ? -c * a : 0),
|
||
|
g = i + ("top" !== r ? c * o : 0),
|
||
|
p = n + ("bottom" !== r ? -c * o : 0);
|
||
|
h !== f && ((i = g), (n = p)), g !== p && ((t = h), (e = f));
|
||
|
}
|
||
|
s.beginPath(),
|
||
|
(s.fillStyle = l.backgroundColor),
|
||
|
(s.strokeStyle = l.borderColor),
|
||
|
(s.lineWidth = u);
|
||
|
var m = [
|
||
|
[t, n],
|
||
|
[t, i],
|
||
|
[e, i],
|
||
|
[e, n],
|
||
|
],
|
||
|
v = ["bottom", "left", "top", "right"].indexOf(r, 0);
|
||
|
function b(t) {
|
||
|
return m[(v + t) % 4];
|
||
|
}
|
||
|
-1 === v && (v = 0);
|
||
|
var x = b(0);
|
||
|
s.moveTo(x[0], x[1]);
|
||
|
for (var y = 1; y < 4; y++) (x = b(y)), s.lineTo(x[0], x[1]);
|
||
|
s.fill(), u && s.stroke();
|
||
|
},
|
||
|
height: function () {
|
||
|
var t = this._view;
|
||
|
return t.base - t.y;
|
||
|
},
|
||
|
inRange: function (t, e) {
|
||
|
var i = !1;
|
||
|
if (this._view) {
|
||
|
var n = r(this);
|
||
|
i =
|
||
|
t >= n.left && t <= n.right && e >= n.top && e <= n.bottom;
|
||
|
}
|
||
|
return i;
|
||
|
},
|
||
|
inLabelRange: function (t, e) {
|
||
|
if (!this._view) return !1;
|
||
|
var i = r(this);
|
||
|
return o(this)
|
||
|
? t >= i.left && t <= i.right
|
||
|
: e >= i.top && e <= i.bottom;
|
||
|
},
|
||
|
inXRange: function (t) {
|
||
|
var e = r(this);
|
||
|
return t >= e.left && t <= e.right;
|
||
|
},
|
||
|
inYRange: function (t) {
|
||
|
var e = r(this);
|
||
|
return t >= e.top && t <= e.bottom;
|
||
|
},
|
||
|
getCenterPoint: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i = this._view;
|
||
|
return (
|
||
|
o(this)
|
||
|
? ((t = i.x), (e = (i.y + i.base) / 2))
|
||
|
: ((t = (i.x + i.base) / 2), (e = i.y)),
|
||
|
{ x: t, y: e }
|
||
|
);
|
||
|
},
|
||
|
getArea: function () {
|
||
|
var t = this._view;
|
||
|
return t.width * Math.abs(t.y - t.base);
|
||
|
},
|
||
|
tooltipPosition: function () {
|
||
|
var t = this._view;
|
||
|
return { x: t.x, y: t.y };
|
||
|
},
|
||
|
}));
|
||
|
},
|
||
|
{ 25: 25, 26: 26 },
|
||
|
],
|
||
|
40: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
(e.exports = {}),
|
||
|
(e.exports.Arc = t(36)),
|
||
|
(e.exports.Line = t(37)),
|
||
|
(e.exports.Point = t(38)),
|
||
|
(e.exports.Rectangle = t(39));
|
||
|
},
|
||
|
{ 36: 36, 37: 37, 38: 38, 39: 39 },
|
||
|
],
|
||
|
41: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(42);
|
||
|
i = e.exports = {
|
||
|
clear: function (t) {
|
||
|
t.ctx.clearRect(0, 0, t.width, t.height);
|
||
|
},
|
||
|
roundedRect: function (t, e, i, n, a, o) {
|
||
|
if (o) {
|
||
|
var r = Math.min(o, n / 2),
|
||
|
s = Math.min(o, a / 2);
|
||
|
t.moveTo(e + r, i),
|
||
|
t.lineTo(e + n - r, i),
|
||
|
t.quadraticCurveTo(e + n, i, e + n, i + s),
|
||
|
t.lineTo(e + n, i + a - s),
|
||
|
t.quadraticCurveTo(e + n, i + a, e + n - r, i + a),
|
||
|
t.lineTo(e + r, i + a),
|
||
|
t.quadraticCurveTo(e, i + a, e, i + a - s),
|
||
|
t.lineTo(e, i + s),
|
||
|
t.quadraticCurveTo(e, i, e + r, i);
|
||
|
} else t.rect(e, i, n, a);
|
||
|
},
|
||
|
drawPoint: function (t, e, i, n, a) {
|
||
|
var o, r, s, l, u, d;
|
||
|
if (
|
||
|
!e ||
|
||
|
"object" != typeof e ||
|
||
|
("[object HTMLImageElement]" !== (o = e.toString()) &&
|
||
|
"[object HTMLCanvasElement]" !== o)
|
||
|
) {
|
||
|
if (!(isNaN(i) || i <= 0)) {
|
||
|
switch (e) {
|
||
|
default:
|
||
|
t.beginPath(),
|
||
|
t.arc(n, a, i, 0, 2 * Math.PI),
|
||
|
t.closePath(),
|
||
|
t.fill();
|
||
|
break;
|
||
|
case "triangle":
|
||
|
t.beginPath(),
|
||
|
(u = ((r = (3 * i) / Math.sqrt(3)) * Math.sqrt(3)) / 2),
|
||
|
t.moveTo(n - r / 2, a + u / 3),
|
||
|
t.lineTo(n + r / 2, a + u / 3),
|
||
|
t.lineTo(n, a - (2 * u) / 3),
|
||
|
t.closePath(),
|
||
|
t.fill();
|
||
|
break;
|
||
|
case "rect":
|
||
|
(d = (1 / Math.SQRT2) * i),
|
||
|
t.beginPath(),
|
||
|
t.fillRect(n - d, a - d, 2 * d, 2 * d),
|
||
|
t.strokeRect(n - d, a - d, 2 * d, 2 * d);
|
||
|
break;
|
||
|
case "rectRounded":
|
||
|
var c = i / Math.SQRT2,
|
||
|
h = n - c,
|
||
|
f = a - c,
|
||
|
g = Math.SQRT2 * i;
|
||
|
t.beginPath(),
|
||
|
this.roundedRect(t, h, f, g, g, i / 2),
|
||
|
t.closePath(),
|
||
|
t.fill();
|
||
|
break;
|
||
|
case "rectRot":
|
||
|
(d = (1 / Math.SQRT2) * i),
|
||
|
t.beginPath(),
|
||
|
t.moveTo(n - d, a),
|
||
|
t.lineTo(n, a + d),
|
||
|
t.lineTo(n + d, a),
|
||
|
t.lineTo(n, a - d),
|
||
|
t.closePath(),
|
||
|
t.fill();
|
||
|
break;
|
||
|
case "cross":
|
||
|
t.beginPath(),
|
||
|
t.moveTo(n, a + i),
|
||
|
t.lineTo(n, a - i),
|
||
|
t.moveTo(n - i, a),
|
||
|
t.lineTo(n + i, a),
|
||
|
t.closePath();
|
||
|
break;
|
||
|
case "crossRot":
|
||
|
t.beginPath(),
|
||
|
(s = Math.cos(Math.PI / 4) * i),
|
||
|
(l = Math.sin(Math.PI / 4) * i),
|
||
|
t.moveTo(n - s, a - l),
|
||
|
t.lineTo(n + s, a + l),
|
||
|
t.moveTo(n - s, a + l),
|
||
|
t.lineTo(n + s, a - l),
|
||
|
t.closePath();
|
||
|
break;
|
||
|
case "star":
|
||
|
t.beginPath(),
|
||
|
t.moveTo(n, a + i),
|
||
|
t.lineTo(n, a - i),
|
||
|
t.moveTo(n - i, a),
|
||
|
t.lineTo(n + i, a),
|
||
|
(s = Math.cos(Math.PI / 4) * i),
|
||
|
(l = Math.sin(Math.PI / 4) * i),
|
||
|
t.moveTo(n - s, a - l),
|
||
|
t.lineTo(n + s, a + l),
|
||
|
t.moveTo(n - s, a + l),
|
||
|
t.lineTo(n + s, a - l),
|
||
|
t.closePath();
|
||
|
break;
|
||
|
case "line":
|
||
|
t.beginPath(),
|
||
|
t.moveTo(n - i, a),
|
||
|
t.lineTo(n + i, a),
|
||
|
t.closePath();
|
||
|
break;
|
||
|
case "dash":
|
||
|
t.beginPath(),
|
||
|
t.moveTo(n, a),
|
||
|
t.lineTo(n + i, a),
|
||
|
t.closePath();
|
||
|
}
|
||
|
t.stroke();
|
||
|
}
|
||
|
} else
|
||
|
t.drawImage(
|
||
|
e,
|
||
|
n - e.width / 2,
|
||
|
a - e.height / 2,
|
||
|
e.width,
|
||
|
e.height
|
||
|
);
|
||
|
},
|
||
|
clipArea: function (t, e) {
|
||
|
t.save(),
|
||
|
t.beginPath(),
|
||
|
t.rect(e.left, e.top, e.right - e.left, e.bottom - e.top),
|
||
|
t.clip();
|
||
|
},
|
||
|
unclipArea: function (t) {
|
||
|
t.restore();
|
||
|
},
|
||
|
lineTo: function (t, e, i, n) {
|
||
|
if (i.steppedLine)
|
||
|
return (
|
||
|
("after" === i.steppedLine && !n) ||
|
||
|
("after" !== i.steppedLine && n)
|
||
|
? t.lineTo(e.x, i.y)
|
||
|
: t.lineTo(i.x, e.y),
|
||
|
void t.lineTo(i.x, i.y)
|
||
|
);
|
||
|
i.tension
|
||
|
? t.bezierCurveTo(
|
||
|
n ? e.controlPointPreviousX : e.controlPointNextX,
|
||
|
n ? e.controlPointPreviousY : e.controlPointNextY,
|
||
|
n ? i.controlPointNextX : i.controlPointPreviousX,
|
||
|
n ? i.controlPointNextY : i.controlPointPreviousY,
|
||
|
i.x,
|
||
|
i.y
|
||
|
)
|
||
|
: t.lineTo(i.x, i.y);
|
||
|
},
|
||
|
};
|
||
|
(n.clear = i.clear),
|
||
|
(n.drawRoundedRectangle = function (t) {
|
||
|
t.beginPath(), i.roundedRect.apply(i, arguments), t.closePath();
|
||
|
});
|
||
|
},
|
||
|
{ 42: 42 },
|
||
|
],
|
||
|
42: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n,
|
||
|
a = {
|
||
|
noop: function () {},
|
||
|
uid:
|
||
|
((n = 0),
|
||
|
function () {
|
||
|
return n++;
|
||
|
}),
|
||
|
isNullOrUndef: function (t) {
|
||
|
return null == t;
|
||
|
},
|
||
|
isArray: Array.isArray
|
||
|
? Array.isArray
|
||
|
: function (t) {
|
||
|
return (
|
||
|
"[object Array]" === Object.prototype.toString.call(t)
|
||
|
);
|
||
|
},
|
||
|
isObject: function (t) {
|
||
|
return (
|
||
|
null !== t &&
|
||
|
"[object Object]" === Object.prototype.toString.call(t)
|
||
|
);
|
||
|
},
|
||
|
valueOrDefault: function (t, e) {
|
||
|
return void 0 === t ? e : t;
|
||
|
},
|
||
|
valueAtIndexOrDefault: function (t, e, i) {
|
||
|
return a.valueOrDefault(a.isArray(t) ? t[e] : t, i);
|
||
|
},
|
||
|
callback: function (t, e, i) {
|
||
|
if (t && "function" == typeof t.call) return t.apply(i, e);
|
||
|
},
|
||
|
each: function (t, e, i, n) {
|
||
|
var o, r, s;
|
||
|
if (a.isArray(t))
|
||
|
if (((r = t.length), n))
|
||
|
for (o = r - 1; o >= 0; o--) e.call(i, t[o], o);
|
||
|
else for (o = 0; o < r; o++) e.call(i, t[o], o);
|
||
|
else if (a.isObject(t))
|
||
|
for (r = (s = Object.keys(t)).length, o = 0; o < r; o++)
|
||
|
e.call(i, t[s[o]], s[o]);
|
||
|
},
|
||
|
arrayEquals: function (t, e) {
|
||
|
var i, n, o, r;
|
||
|
if (!t || !e || t.length !== e.length) return !1;
|
||
|
for (i = 0, n = t.length; i < n; ++i)
|
||
|
if (
|
||
|
((o = t[i]),
|
||
|
(r = e[i]),
|
||
|
o instanceof Array && r instanceof Array)
|
||
|
) {
|
||
|
if (!a.arrayEquals(o, r)) return !1;
|
||
|
} else if (o !== r) return !1;
|
||
|
return !0;
|
||
|
},
|
||
|
clone: function (t) {
|
||
|
if (a.isArray(t)) return t.map(a.clone);
|
||
|
if (a.isObject(t)) {
|
||
|
for (
|
||
|
var e = {}, i = Object.keys(t), n = i.length, o = 0;
|
||
|
o < n;
|
||
|
++o
|
||
|
)
|
||
|
e[i[o]] = a.clone(t[i[o]]);
|
||
|
return e;
|
||
|
}
|
||
|
return t;
|
||
|
},
|
||
|
_merger: function (t, e, i, n) {
|
||
|
var o = e[t],
|
||
|
r = i[t];
|
||
|
a.isObject(o) && a.isObject(r)
|
||
|
? a.merge(o, r, n)
|
||
|
: (e[t] = a.clone(r));
|
||
|
},
|
||
|
_mergerIf: function (t, e, i) {
|
||
|
var n = e[t],
|
||
|
o = i[t];
|
||
|
a.isObject(n) && a.isObject(o)
|
||
|
? a.mergeIf(n, o)
|
||
|
: e.hasOwnProperty(t) || (e[t] = a.clone(o));
|
||
|
},
|
||
|
merge: function (t, e, i) {
|
||
|
var n,
|
||
|
o,
|
||
|
r,
|
||
|
s,
|
||
|
l,
|
||
|
u = a.isArray(e) ? e : [e],
|
||
|
d = u.length;
|
||
|
if (!a.isObject(t)) return t;
|
||
|
for (n = (i = i || {}).merger || a._merger, o = 0; o < d; ++o)
|
||
|
if (((e = u[o]), a.isObject(e)))
|
||
|
for (l = 0, s = (r = Object.keys(e)).length; l < s; ++l)
|
||
|
n(r[l], t, e, i);
|
||
|
return t;
|
||
|
},
|
||
|
mergeIf: function (t, e) {
|
||
|
return a.merge(t, e, { merger: a._mergerIf });
|
||
|
},
|
||
|
extend: function (t) {
|
||
|
for (
|
||
|
var e = function (e, i) {
|
||
|
t[i] = e;
|
||
|
},
|
||
|
i = 1,
|
||
|
n = arguments.length;
|
||
|
i < n;
|
||
|
++i
|
||
|
)
|
||
|
a.each(arguments[i], e);
|
||
|
return t;
|
||
|
},
|
||
|
inherits: function (t) {
|
||
|
var e = this,
|
||
|
i =
|
||
|
t && t.hasOwnProperty("constructor")
|
||
|
? t.constructor
|
||
|
: function () {
|
||
|
return e.apply(this, arguments);
|
||
|
},
|
||
|
n = function () {
|
||
|
this.constructor = i;
|
||
|
};
|
||
|
return (
|
||
|
(n.prototype = e.prototype),
|
||
|
(i.prototype = new n()),
|
||
|
(i.extend = a.inherits),
|
||
|
t && a.extend(i.prototype, t),
|
||
|
(i.__super__ = e.prototype),
|
||
|
i
|
||
|
);
|
||
|
},
|
||
|
};
|
||
|
(e.exports = a),
|
||
|
(a.callCallback = a.callback),
|
||
|
(a.indexOf = function (t, e, i) {
|
||
|
return Array.prototype.indexOf.call(t, e, i);
|
||
|
}),
|
||
|
(a.getValueOrDefault = a.valueOrDefault),
|
||
|
(a.getValueAtIndexOrDefault = a.valueAtIndexOrDefault);
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
43: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(42),
|
||
|
a = {
|
||
|
linear: function (t) {
|
||
|
return t;
|
||
|
},
|
||
|
easeInQuad: function (t) {
|
||
|
return t * t;
|
||
|
},
|
||
|
easeOutQuad: function (t) {
|
||
|
return -t * (t - 2);
|
||
|
},
|
||
|
easeInOutQuad: function (t) {
|
||
|
return (t /= 0.5) < 1
|
||
|
? 0.5 * t * t
|
||
|
: -0.5 * (--t * (t - 2) - 1);
|
||
|
},
|
||
|
easeInCubic: function (t) {
|
||
|
return t * t * t;
|
||
|
},
|
||
|
easeOutCubic: function (t) {
|
||
|
return (t -= 1) * t * t + 1;
|
||
|
},
|
||
|
easeInOutCubic: function (t) {
|
||
|
return (t /= 0.5) < 1
|
||
|
? 0.5 * t * t * t
|
||
|
: 0.5 * ((t -= 2) * t * t + 2);
|
||
|
},
|
||
|
easeInQuart: function (t) {
|
||
|
return t * t * t * t;
|
||
|
},
|
||
|
easeOutQuart: function (t) {
|
||
|
return -((t -= 1) * t * t * t - 1);
|
||
|
},
|
||
|
easeInOutQuart: function (t) {
|
||
|
return (t /= 0.5) < 1
|
||
|
? 0.5 * t * t * t * t
|
||
|
: -0.5 * ((t -= 2) * t * t * t - 2);
|
||
|
},
|
||
|
easeInQuint: function (t) {
|
||
|
return t * t * t * t * t;
|
||
|
},
|
||
|
easeOutQuint: function (t) {
|
||
|
return (t -= 1) * t * t * t * t + 1;
|
||
|
},
|
||
|
easeInOutQuint: function (t) {
|
||
|
return (t /= 0.5) < 1
|
||
|
? 0.5 * t * t * t * t * t
|
||
|
: 0.5 * ((t -= 2) * t * t * t * t + 2);
|
||
|
},
|
||
|
easeInSine: function (t) {
|
||
|
return 1 - Math.cos(t * (Math.PI / 2));
|
||
|
},
|
||
|
easeOutSine: function (t) {
|
||
|
return Math.sin(t * (Math.PI / 2));
|
||
|
},
|
||
|
easeInOutSine: function (t) {
|
||
|
return -0.5 * (Math.cos(Math.PI * t) - 1);
|
||
|
},
|
||
|
easeInExpo: function (t) {
|
||
|
return 0 === t ? 0 : Math.pow(2, 10 * (t - 1));
|
||
|
},
|
||
|
easeOutExpo: function (t) {
|
||
|
return 1 === t ? 1 : 1 - Math.pow(2, -10 * t);
|
||
|
},
|
||
|
easeInOutExpo: function (t) {
|
||
|
return 0 === t
|
||
|
? 0
|
||
|
: 1 === t
|
||
|
? 1
|
||
|
: (t /= 0.5) < 1
|
||
|
? 0.5 * Math.pow(2, 10 * (t - 1))
|
||
|
: 0.5 * (2 - Math.pow(2, -10 * --t));
|
||
|
},
|
||
|
easeInCirc: function (t) {
|
||
|
return t >= 1 ? t : -(Math.sqrt(1 - t * t) - 1);
|
||
|
},
|
||
|
easeOutCirc: function (t) {
|
||
|
return Math.sqrt(1 - (t -= 1) * t);
|
||
|
},
|
||
|
easeInOutCirc: function (t) {
|
||
|
return (t /= 0.5) < 1
|
||
|
? -0.5 * (Math.sqrt(1 - t * t) - 1)
|
||
|
: 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1);
|
||
|
},
|
||
|
easeInElastic: function (t) {
|
||
|
var e = 1.70158,
|
||
|
i = 0,
|
||
|
n = 1;
|
||
|
return 0 === t
|
||
|
? 0
|
||
|
: 1 === t
|
||
|
? 1
|
||
|
: (i || (i = 0.3),
|
||
|
n < 1
|
||
|
? ((n = 1), (e = i / 4))
|
||
|
: (e = (i / (2 * Math.PI)) * Math.asin(1 / n)),
|
||
|
-n *
|
||
|
Math.pow(2, 10 * (t -= 1)) *
|
||
|
Math.sin(((t - e) * (2 * Math.PI)) / i));
|
||
|
},
|
||
|
easeOutElastic: function (t) {
|
||
|
var e = 1.70158,
|
||
|
i = 0,
|
||
|
n = 1;
|
||
|
return 0 === t
|
||
|
? 0
|
||
|
: 1 === t
|
||
|
? 1
|
||
|
: (i || (i = 0.3),
|
||
|
n < 1
|
||
|
? ((n = 1), (e = i / 4))
|
||
|
: (e = (i / (2 * Math.PI)) * Math.asin(1 / n)),
|
||
|
n *
|
||
|
Math.pow(2, -10 * t) *
|
||
|
Math.sin(((t - e) * (2 * Math.PI)) / i) +
|
||
|
1);
|
||
|
},
|
||
|
easeInOutElastic: function (t) {
|
||
|
var e = 1.70158,
|
||
|
i = 0,
|
||
|
n = 1;
|
||
|
return 0 === t
|
||
|
? 0
|
||
|
: 2 == (t /= 0.5)
|
||
|
? 1
|
||
|
: (i || (i = 0.45),
|
||
|
n < 1
|
||
|
? ((n = 1), (e = i / 4))
|
||
|
: (e = (i / (2 * Math.PI)) * Math.asin(1 / n)),
|
||
|
t < 1
|
||
|
? n *
|
||
|
Math.pow(2, 10 * (t -= 1)) *
|
||
|
Math.sin(((t - e) * (2 * Math.PI)) / i) *
|
||
|
-0.5
|
||
|
: n *
|
||
|
Math.pow(2, -10 * (t -= 1)) *
|
||
|
Math.sin(((t - e) * (2 * Math.PI)) / i) *
|
||
|
0.5 +
|
||
|
1);
|
||
|
},
|
||
|
easeInBack: function (t) {
|
||
|
return t * t * (2.70158 * t - 1.70158);
|
||
|
},
|
||
|
easeOutBack: function (t) {
|
||
|
return (t -= 1) * t * (2.70158 * t + 1.70158) + 1;
|
||
|
},
|
||
|
easeInOutBack: function (t) {
|
||
|
var e = 1.70158;
|
||
|
return (t /= 0.5) < 1
|
||
|
? t * t * ((1 + (e *= 1.525)) * t - e) * 0.5
|
||
|
: 0.5 * ((t -= 2) * t * ((1 + (e *= 1.525)) * t + e) + 2);
|
||
|
},
|
||
|
easeInBounce: function (t) {
|
||
|
return 1 - a.easeOutBounce(1 - t);
|
||
|
},
|
||
|
easeOutBounce: function (t) {
|
||
|
return t < 1 / 2.75
|
||
|
? 7.5625 * t * t
|
||
|
: t < 2 / 2.75
|
||
|
? 7.5625 * (t -= 1.5 / 2.75) * t + 0.75
|
||
|
: t < 2.5 / 2.75
|
||
|
? 7.5625 * (t -= 2.25 / 2.75) * t + 0.9375
|
||
|
: 7.5625 * (t -= 2.625 / 2.75) * t + 0.984375;
|
||
|
},
|
||
|
easeInOutBounce: function (t) {
|
||
|
return t < 0.5
|
||
|
? 0.5 * a.easeInBounce(2 * t)
|
||
|
: 0.5 * a.easeOutBounce(2 * t - 1) + 0.5;
|
||
|
},
|
||
|
};
|
||
|
(e.exports = { effects: a }), (n.easingEffects = a);
|
||
|
},
|
||
|
{ 42: 42 },
|
||
|
],
|
||
|
44: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(42);
|
||
|
e.exports = {
|
||
|
toLineHeight: function (t, e) {
|
||
|
var i = ("" + t).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/);
|
||
|
if (!i || "normal" === i[1]) return 1.2 * e;
|
||
|
switch (((t = +i[2]), i[3])) {
|
||
|
case "px":
|
||
|
return t;
|
||
|
case "%":
|
||
|
t /= 100;
|
||
|
}
|
||
|
return e * t;
|
||
|
},
|
||
|
toPadding: function (t) {
|
||
|
var e, i, a, o;
|
||
|
return (
|
||
|
n.isObject(t)
|
||
|
? ((e = +t.top || 0),
|
||
|
(i = +t.right || 0),
|
||
|
(a = +t.bottom || 0),
|
||
|
(o = +t.left || 0))
|
||
|
: (e = i = a = o = +t || 0),
|
||
|
{
|
||
|
top: e,
|
||
|
right: i,
|
||
|
bottom: a,
|
||
|
left: o,
|
||
|
height: e + a,
|
||
|
width: o + i,
|
||
|
}
|
||
|
);
|
||
|
},
|
||
|
resolve: function (t, e, i) {
|
||
|
var a, o, r;
|
||
|
for (a = 0, o = t.length; a < o; ++a)
|
||
|
if (
|
||
|
void 0 !== (r = t[a]) &&
|
||
|
(void 0 !== e && "function" == typeof r && (r = r(e)),
|
||
|
void 0 !== i && n.isArray(r) && (r = r[i]),
|
||
|
void 0 !== r)
|
||
|
)
|
||
|
return r;
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{ 42: 42 },
|
||
|
],
|
||
|
45: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
(e.exports = t(42)),
|
||
|
(e.exports.easing = t(43)),
|
||
|
(e.exports.canvas = t(41)),
|
||
|
(e.exports.options = t(44));
|
||
|
},
|
||
|
{ 41: 41, 42: 42, 43: 43, 44: 44 },
|
||
|
],
|
||
|
46: [
|
||
|
function (t, e, i) {
|
||
|
e.exports = {
|
||
|
acquireContext: function (t) {
|
||
|
return (
|
||
|
t && t.canvas && (t = t.canvas),
|
||
|
(t && t.getContext("2d")) || null
|
||
|
);
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
47: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45),
|
||
|
a = "$chartjs",
|
||
|
o = "chartjs-",
|
||
|
r = o + "render-monitor",
|
||
|
s = o + "render-animation",
|
||
|
l = ["animationstart", "webkitAnimationStart"],
|
||
|
u = {
|
||
|
touchstart: "mousedown",
|
||
|
touchmove: "mousemove",
|
||
|
touchend: "mouseup",
|
||
|
pointerenter: "mouseenter",
|
||
|
pointerdown: "mousedown",
|
||
|
pointermove: "mousemove",
|
||
|
pointerup: "mouseup",
|
||
|
pointerleave: "mouseout",
|
||
|
pointerout: "mouseout",
|
||
|
};
|
||
|
function d(t, e) {
|
||
|
var i = n.getStyle(t, e),
|
||
|
a = i && i.match(/^(\d+)(\.\d+)?px$/);
|
||
|
return a ? Number(a[1]) : void 0;
|
||
|
}
|
||
|
var c = !!(function () {
|
||
|
var t = !1;
|
||
|
try {
|
||
|
var e = Object.defineProperty({}, "passive", {
|
||
|
get: function () {
|
||
|
t = !0;
|
||
|
},
|
||
|
});
|
||
|
window.addEventListener("e", null, e);
|
||
|
} catch (t) {}
|
||
|
return t;
|
||
|
})() && { passive: !0 };
|
||
|
function h(t, e, i) {
|
||
|
t.addEventListener(e, i, c);
|
||
|
}
|
||
|
function f(t, e, i) {
|
||
|
t.removeEventListener(e, i, c);
|
||
|
}
|
||
|
function g(t, e, i, n, a) {
|
||
|
return {
|
||
|
type: t,
|
||
|
chart: e,
|
||
|
native: a || null,
|
||
|
x: void 0 !== i ? i : null,
|
||
|
y: void 0 !== n ? n : null,
|
||
|
};
|
||
|
}
|
||
|
function p(t, e, i) {
|
||
|
var u,
|
||
|
d,
|
||
|
c,
|
||
|
f,
|
||
|
p,
|
||
|
m,
|
||
|
v,
|
||
|
b,
|
||
|
x = t[a] || (t[a] = {}),
|
||
|
y = (x.resizer = (function (t) {
|
||
|
var e = document.createElement("div"),
|
||
|
i = o + "size-monitor",
|
||
|
n =
|
||
|
"position:absolute;left:0;top:0;right:0;bottom:0;overflow:hidden;pointer-events:none;visibility:hidden;z-index:-1;";
|
||
|
(e.style.cssText = n),
|
||
|
(e.className = i),
|
||
|
(e.innerHTML =
|
||
|
'<div class="' +
|
||
|
i +
|
||
|
'-expand" style="' +
|
||
|
n +
|
||
|
'"><div style="position:absolute;width:1000000px;height:1000000px;left:0;top:0"></div></div><div class="' +
|
||
|
i +
|
||
|
'-shrink" style="' +
|
||
|
n +
|
||
|
'"><div style="position:absolute;width:200%;height:200%;left:0; top:0"></div></div>');
|
||
|
var a = e.childNodes[0],
|
||
|
r = e.childNodes[1];
|
||
|
e._reset = function () {
|
||
|
(a.scrollLeft = 1e6),
|
||
|
(a.scrollTop = 1e6),
|
||
|
(r.scrollLeft = 1e6),
|
||
|
(r.scrollTop = 1e6);
|
||
|
};
|
||
|
var s = function () {
|
||
|
e._reset(), t();
|
||
|
};
|
||
|
return (
|
||
|
h(a, "scroll", s.bind(a, "expand")),
|
||
|
h(r, "scroll", s.bind(r, "shrink")),
|
||
|
e
|
||
|
);
|
||
|
})(
|
||
|
((u = function () {
|
||
|
if (x.resizer) return e(g("resize", i));
|
||
|
}),
|
||
|
(c = !1),
|
||
|
(f = []),
|
||
|
function () {
|
||
|
(f = Array.prototype.slice.call(arguments)),
|
||
|
(d = d || this),
|
||
|
c ||
|
||
|
((c = !0),
|
||
|
n.requestAnimFrame.call(window, function () {
|
||
|
(c = !1), u.apply(d, f);
|
||
|
}));
|
||
|
})
|
||
|
));
|
||
|
(m = function () {
|
||
|
if (x.resizer) {
|
||
|
var e = t.parentNode;
|
||
|
e && e !== y.parentNode && e.insertBefore(y, e.firstChild),
|
||
|
y._reset();
|
||
|
}
|
||
|
}),
|
||
|
(v = (p = t)[a] || (p[a] = {})),
|
||
|
(b = v.renderProxy =
|
||
|
function (t) {
|
||
|
t.animationName === s && m();
|
||
|
}),
|
||
|
n.each(l, function (t) {
|
||
|
h(p, t, b);
|
||
|
}),
|
||
|
(v.reflow = !!p.offsetParent),
|
||
|
p.classList.add(r);
|
||
|
}
|
||
|
function m(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
o,
|
||
|
s = t[a] || {},
|
||
|
u = s.resizer;
|
||
|
delete s.resizer,
|
||
|
(i = (e = t)[a] || {}),
|
||
|
(o = i.renderProxy) &&
|
||
|
(n.each(l, function (t) {
|
||
|
f(e, t, o);
|
||
|
}),
|
||
|
delete i.renderProxy),
|
||
|
e.classList.remove(r),
|
||
|
u && u.parentNode && u.parentNode.removeChild(u);
|
||
|
}
|
||
|
(e.exports = {
|
||
|
_enabled:
|
||
|
"undefined" != typeof window && "undefined" != typeof document,
|
||
|
initialize: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i,
|
||
|
n = "from{opacity:0.99}to{opacity:1}";
|
||
|
(e =
|
||
|
"@-webkit-keyframes " +
|
||
|
s +
|
||
|
"{" +
|
||
|
n +
|
||
|
"}@keyframes " +
|
||
|
s +
|
||
|
"{" +
|
||
|
n +
|
||
|
"}." +
|
||
|
r +
|
||
|
"{-webkit-animation:" +
|
||
|
s +
|
||
|
" 0.001s;animation:" +
|
||
|
s +
|
||
|
" 0.001s;}"),
|
||
|
(i = (t = this)._style || document.createElement("style")),
|
||
|
t._style ||
|
||
|
((t._style = i),
|
||
|
(e = "/* Chart.js */\n" + e),
|
||
|
i.setAttribute("type", "text/css"),
|
||
|
document.getElementsByTagName("head")[0].appendChild(i)),
|
||
|
i.appendChild(document.createTextNode(e));
|
||
|
},
|
||
|
acquireContext: function (t, e) {
|
||
|
"string" == typeof t
|
||
|
? (t = document.getElementById(t))
|
||
|
: t.length && (t = t[0]),
|
||
|
t && t.canvas && (t = t.canvas);
|
||
|
var i = t && t.getContext && t.getContext("2d");
|
||
|
return i && i.canvas === t
|
||
|
? ((function (t, e) {
|
||
|
var i = t.style,
|
||
|
n = t.getAttribute("height"),
|
||
|
o = t.getAttribute("width");
|
||
|
if (
|
||
|
((t[a] = {
|
||
|
initial: {
|
||
|
height: n,
|
||
|
width: o,
|
||
|
style: {
|
||
|
display: i.display,
|
||
|
height: i.height,
|
||
|
width: i.width,
|
||
|
},
|
||
|
},
|
||
|
}),
|
||
|
(i.display = i.display || "block"),
|
||
|
null === o || "" === o)
|
||
|
) {
|
||
|
var r = d(t, "width");
|
||
|
void 0 !== r && (t.width = r);
|
||
|
}
|
||
|
if (null === n || "" === n)
|
||
|
if ("" === t.style.height)
|
||
|
t.height = t.width / (e.options.aspectRatio || 2);
|
||
|
else {
|
||
|
var s = d(t, "height");
|
||
|
void 0 !== r && (t.height = s);
|
||
|
}
|
||
|
})(t, e),
|
||
|
i)
|
||
|
: null;
|
||
|
},
|
||
|
releaseContext: function (t) {
|
||
|
var e = t.canvas;
|
||
|
if (e[a]) {
|
||
|
var i = e[a].initial;
|
||
|
["height", "width"].forEach(function (t) {
|
||
|
var a = i[t];
|
||
|
n.isNullOrUndef(a)
|
||
|
? e.removeAttribute(t)
|
||
|
: e.setAttribute(t, a);
|
||
|
}),
|
||
|
n.each(i.style || {}, function (t, i) {
|
||
|
e.style[i] = t;
|
||
|
}),
|
||
|
(e.width = e.width),
|
||
|
delete e[a];
|
||
|
}
|
||
|
},
|
||
|
addEventListener: function (t, e, i) {
|
||
|
var o = t.canvas;
|
||
|
if ("resize" !== e) {
|
||
|
var r = i[a] || (i[a] = {});
|
||
|
h(
|
||
|
o,
|
||
|
e,
|
||
|
((r.proxies || (r.proxies = {}))[t.id + "_" + e] = function (
|
||
|
e
|
||
|
) {
|
||
|
var a, o, r, s;
|
||
|
i(
|
||
|
((o = t),
|
||
|
(r = u[(a = e).type] || a.type),
|
||
|
(s = n.getRelativePosition(a, o)),
|
||
|
g(r, o, s.x, s.y, a))
|
||
|
);
|
||
|
})
|
||
|
);
|
||
|
} else p(o, i, t);
|
||
|
},
|
||
|
removeEventListener: function (t, e, i) {
|
||
|
var n = t.canvas;
|
||
|
if ("resize" !== e) {
|
||
|
var o = ((i[a] || {}).proxies || {})[t.id + "_" + e];
|
||
|
o && f(n, e, o);
|
||
|
} else m(n);
|
||
|
},
|
||
|
}),
|
||
|
(n.addEvent = h),
|
||
|
(n.removeEvent = f);
|
||
|
},
|
||
|
{ 45: 45 },
|
||
|
],
|
||
|
48: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45),
|
||
|
a = t(46),
|
||
|
o = t(47),
|
||
|
r = o._enabled ? o : a;
|
||
|
e.exports = n.extend(
|
||
|
{
|
||
|
initialize: function () {},
|
||
|
acquireContext: function () {},
|
||
|
releaseContext: function () {},
|
||
|
addEventListener: function () {},
|
||
|
removeEventListener: function () {},
|
||
|
},
|
||
|
r
|
||
|
);
|
||
|
},
|
||
|
{ 45: 45, 46: 46, 47: 47 },
|
||
|
],
|
||
|
49: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
(e.exports = {}),
|
||
|
(e.exports.filler = t(50)),
|
||
|
(e.exports.legend = t(51)),
|
||
|
(e.exports.title = t(52));
|
||
|
},
|
||
|
{ 50: 50, 51: 51, 52: 52 },
|
||
|
],
|
||
|
50: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(40),
|
||
|
o = t(45);
|
||
|
n._set("global", { plugins: { filler: { propagate: !0 } } });
|
||
|
var r = {
|
||
|
dataset: function (t) {
|
||
|
var e = t.fill,
|
||
|
i = t.chart,
|
||
|
n = i.getDatasetMeta(e),
|
||
|
a = (n && i.isDatasetVisible(e) && n.dataset._children) || [],
|
||
|
o = a.length || 0;
|
||
|
return o
|
||
|
? function (t, e) {
|
||
|
return (e < o && a[e]._view) || null;
|
||
|
}
|
||
|
: null;
|
||
|
},
|
||
|
boundary: function (t) {
|
||
|
var e = t.boundary,
|
||
|
i = e ? e.x : null,
|
||
|
n = e ? e.y : null;
|
||
|
return function (t) {
|
||
|
return { x: null === i ? t.x : i, y: null === n ? t.y : n };
|
||
|
};
|
||
|
},
|
||
|
};
|
||
|
function s(t, e, i) {
|
||
|
var n,
|
||
|
a = t._model || {},
|
||
|
o = a.fill;
|
||
|
if (
|
||
|
(void 0 === o && (o = !!a.backgroundColor),
|
||
|
!1 === o || null === o)
|
||
|
)
|
||
|
return !1;
|
||
|
if (!0 === o) return "origin";
|
||
|
if (((n = parseFloat(o, 10)), isFinite(n) && Math.floor(n) === n))
|
||
|
return (
|
||
|
("-" !== o[0] && "+" !== o[0]) || (n = e + n),
|
||
|
!(n === e || n < 0 || n >= i) && n
|
||
|
);
|
||
|
switch (o) {
|
||
|
case "bottom":
|
||
|
return "start";
|
||
|
case "top":
|
||
|
return "end";
|
||
|
case "zero":
|
||
|
return "origin";
|
||
|
case "origin":
|
||
|
case "start":
|
||
|
case "end":
|
||
|
return o;
|
||
|
default:
|
||
|
return !1;
|
||
|
}
|
||
|
}
|
||
|
function l(t) {
|
||
|
var e,
|
||
|
i = t.el._model || {},
|
||
|
n = t.el._scale || {},
|
||
|
a = t.fill,
|
||
|
o = null;
|
||
|
if (isFinite(a)) return null;
|
||
|
if (
|
||
|
("start" === a
|
||
|
? (o = void 0 === i.scaleBottom ? n.bottom : i.scaleBottom)
|
||
|
: "end" === a
|
||
|
? (o = void 0 === i.scaleTop ? n.top : i.scaleTop)
|
||
|
: void 0 !== i.scaleZero
|
||
|
? (o = i.scaleZero)
|
||
|
: n.getBasePosition
|
||
|
? (o = n.getBasePosition())
|
||
|
: n.getBasePixel && (o = n.getBasePixel()),
|
||
|
null != o)
|
||
|
) {
|
||
|
if (void 0 !== o.x && void 0 !== o.y) return o;
|
||
|
if ("number" == typeof o && isFinite(o))
|
||
|
return {
|
||
|
x: (e = n.isHorizontal()) ? o : null,
|
||
|
y: e ? null : o,
|
||
|
};
|
||
|
}
|
||
|
return null;
|
||
|
}
|
||
|
function u(t, e, i) {
|
||
|
var n,
|
||
|
a = t[e].fill,
|
||
|
o = [e];
|
||
|
if (!i) return a;
|
||
|
for (; !1 !== a && -1 === o.indexOf(a); ) {
|
||
|
if (!isFinite(a)) return a;
|
||
|
if (!(n = t[a])) return !1;
|
||
|
if (n.visible) return a;
|
||
|
o.push(a), (a = n.fill);
|
||
|
}
|
||
|
return !1;
|
||
|
}
|
||
|
function d(t) {
|
||
|
return t && !t.skip;
|
||
|
}
|
||
|
function c(t, e, i, n, a) {
|
||
|
var r;
|
||
|
if (n && a) {
|
||
|
for (t.moveTo(e[0].x, e[0].y), r = 1; r < n; ++r)
|
||
|
o.canvas.lineTo(t, e[r - 1], e[r]);
|
||
|
for (t.lineTo(i[a - 1].x, i[a - 1].y), r = a - 1; r > 0; --r)
|
||
|
o.canvas.lineTo(t, i[r], i[r - 1], !0);
|
||
|
}
|
||
|
}
|
||
|
e.exports = {
|
||
|
id: "filler",
|
||
|
afterDatasetsUpdate: function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
o,
|
||
|
d,
|
||
|
c,
|
||
|
h,
|
||
|
f,
|
||
|
g = (t.data.datasets || []).length,
|
||
|
p = e.propagate,
|
||
|
m = [];
|
||
|
for (n = 0; n < g; ++n)
|
||
|
(d = null),
|
||
|
(o = (i = t.getDatasetMeta(n)).dataset) &&
|
||
|
o._model &&
|
||
|
o instanceof a.Line &&
|
||
|
(d = {
|
||
|
visible: t.isDatasetVisible(n),
|
||
|
fill: s(o, n, g),
|
||
|
chart: t,
|
||
|
el: o,
|
||
|
}),
|
||
|
(i.$filler = d),
|
||
|
m.push(d);
|
||
|
for (n = 0; n < g; ++n)
|
||
|
(d = m[n]) &&
|
||
|
((d.fill = u(m, n, p)),
|
||
|
(d.boundary = l(d)),
|
||
|
(d.mapper =
|
||
|
(void 0,
|
||
|
(f = void 0),
|
||
|
(h = (c = d).fill),
|
||
|
(f = "dataset"),
|
||
|
!1 === h
|
||
|
? null
|
||
|
: (isFinite(h) || (f = "boundary"), r[f](c)))));
|
||
|
},
|
||
|
beforeDatasetDraw: function (t, e) {
|
||
|
var i = e.meta.$filler;
|
||
|
if (i) {
|
||
|
var a = t.ctx,
|
||
|
r = i.el,
|
||
|
s = r._view,
|
||
|
l = r._children || [],
|
||
|
u = i.mapper,
|
||
|
h = s.backgroundColor || n.global.defaultColor;
|
||
|
u &&
|
||
|
h &&
|
||
|
l.length &&
|
||
|
(o.canvas.clipArea(a, t.chartArea),
|
||
|
(function (t, e, i, n, a, o) {
|
||
|
var r,
|
||
|
s,
|
||
|
l,
|
||
|
u,
|
||
|
h,
|
||
|
f,
|
||
|
g,
|
||
|
p = e.length,
|
||
|
m = n.spanGaps,
|
||
|
v = [],
|
||
|
b = [],
|
||
|
x = 0,
|
||
|
y = 0;
|
||
|
for (t.beginPath(), r = 0, s = p + !!o; r < s; ++r)
|
||
|
(h = i((u = e[(l = r % p)]._view), l, n)),
|
||
|
(f = d(u)),
|
||
|
(g = d(h)),
|
||
|
f && g
|
||
|
? ((x = v.push(u)), (y = b.push(h)))
|
||
|
: x &&
|
||
|
y &&
|
||
|
(m
|
||
|
? (f && v.push(u), g && b.push(h))
|
||
|
: (c(t, v, b, x, y),
|
||
|
(x = y = 0),
|
||
|
(v = []),
|
||
|
(b = [])));
|
||
|
c(t, v, b, x, y),
|
||
|
t.closePath(),
|
||
|
(t.fillStyle = a),
|
||
|
t.fill();
|
||
|
})(a, l, u, s, h, r._loop),
|
||
|
o.canvas.unclipArea(a));
|
||
|
}
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{ 25: 25, 40: 40, 45: 45 },
|
||
|
],
|
||
|
51: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26),
|
||
|
o = t(45),
|
||
|
r = t(30),
|
||
|
s = o.noop;
|
||
|
function l(t, e) {
|
||
|
return t.usePointStyle ? e * Math.SQRT2 : t.boxWidth;
|
||
|
}
|
||
|
n._set("global", {
|
||
|
legend: {
|
||
|
display: !0,
|
||
|
position: "top",
|
||
|
fullWidth: !0,
|
||
|
reverse: !1,
|
||
|
weight: 1e3,
|
||
|
onClick: function (t, e) {
|
||
|
var i = e.datasetIndex,
|
||
|
n = this.chart,
|
||
|
a = n.getDatasetMeta(i);
|
||
|
(a.hidden =
|
||
|
null === a.hidden ? !n.data.datasets[i].hidden : null),
|
||
|
n.update();
|
||
|
},
|
||
|
onHover: null,
|
||
|
labels: {
|
||
|
boxWidth: 40,
|
||
|
padding: 10,
|
||
|
generateLabels: function (t) {
|
||
|
var e = t.data;
|
||
|
return o.isArray(e.datasets)
|
||
|
? e.datasets.map(function (e, i) {
|
||
|
return {
|
||
|
text: e.label,
|
||
|
fillStyle: o.isArray(e.backgroundColor)
|
||
|
? e.backgroundColor[0]
|
||
|
: e.backgroundColor,
|
||
|
hidden: !t.isDatasetVisible(i),
|
||
|
lineCap: e.borderCapStyle,
|
||
|
lineDash: e.borderDash,
|
||
|
lineDashOffset: e.borderDashOffset,
|
||
|
lineJoin: e.borderJoinStyle,
|
||
|
lineWidth: e.borderWidth,
|
||
|
strokeStyle: e.borderColor,
|
||
|
pointStyle: e.pointStyle,
|
||
|
datasetIndex: i,
|
||
|
};
|
||
|
}, this)
|
||
|
: [];
|
||
|
},
|
||
|
},
|
||
|
},
|
||
|
legendCallback: function (t) {
|
||
|
var e = [];
|
||
|
e.push('<ul class="' + t.id + '-legend">');
|
||
|
for (var i = 0; i < t.data.datasets.length; i++)
|
||
|
e.push(
|
||
|
'<li><span style="background-color:' +
|
||
|
t.data.datasets[i].backgroundColor +
|
||
|
'"></span>'
|
||
|
),
|
||
|
t.data.datasets[i].label && e.push(t.data.datasets[i].label),
|
||
|
e.push("</li>");
|
||
|
return e.push("</ul>"), e.join("");
|
||
|
},
|
||
|
});
|
||
|
var u = a.extend({
|
||
|
initialize: function (t) {
|
||
|
o.extend(this, t),
|
||
|
(this.legendHitBoxes = []),
|
||
|
(this.doughnutMode = !1);
|
||
|
},
|
||
|
beforeUpdate: s,
|
||
|
update: function (t, e, i) {
|
||
|
var n = this;
|
||
|
return (
|
||
|
n.beforeUpdate(),
|
||
|
(n.maxWidth = t),
|
||
|
(n.maxHeight = e),
|
||
|
(n.margins = i),
|
||
|
n.beforeSetDimensions(),
|
||
|
n.setDimensions(),
|
||
|
n.afterSetDimensions(),
|
||
|
n.beforeBuildLabels(),
|
||
|
n.buildLabels(),
|
||
|
n.afterBuildLabels(),
|
||
|
n.beforeFit(),
|
||
|
n.fit(),
|
||
|
n.afterFit(),
|
||
|
n.afterUpdate(),
|
||
|
n.minSize
|
||
|
);
|
||
|
},
|
||
|
afterUpdate: s,
|
||
|
beforeSetDimensions: s,
|
||
|
setDimensions: function () {
|
||
|
var t = this;
|
||
|
t.isHorizontal()
|
||
|
? ((t.width = t.maxWidth), (t.left = 0), (t.right = t.width))
|
||
|
: ((t.height = t.maxHeight),
|
||
|
(t.top = 0),
|
||
|
(t.bottom = t.height)),
|
||
|
(t.paddingLeft = 0),
|
||
|
(t.paddingTop = 0),
|
||
|
(t.paddingRight = 0),
|
||
|
(t.paddingBottom = 0),
|
||
|
(t.minSize = { width: 0, height: 0 });
|
||
|
},
|
||
|
afterSetDimensions: s,
|
||
|
beforeBuildLabels: s,
|
||
|
buildLabels: function () {
|
||
|
var t = this,
|
||
|
e = t.options.labels || {},
|
||
|
i = o.callback(e.generateLabels, [t.chart], t) || [];
|
||
|
e.filter &&
|
||
|
(i = i.filter(function (i) {
|
||
|
return e.filter(i, t.chart.data);
|
||
|
})),
|
||
|
t.options.reverse && i.reverse(),
|
||
|
(t.legendItems = i);
|
||
|
},
|
||
|
afterBuildLabels: s,
|
||
|
beforeFit: s,
|
||
|
fit: function () {
|
||
|
var t = this,
|
||
|
e = t.options,
|
||
|
i = e.labels,
|
||
|
a = e.display,
|
||
|
r = t.ctx,
|
||
|
s = n.global,
|
||
|
u = o.valueOrDefault,
|
||
|
d = u(i.fontSize, s.defaultFontSize),
|
||
|
c = u(i.fontStyle, s.defaultFontStyle),
|
||
|
h = u(i.fontFamily, s.defaultFontFamily),
|
||
|
f = o.fontString(d, c, h),
|
||
|
g = (t.legendHitBoxes = []),
|
||
|
p = t.minSize,
|
||
|
m = t.isHorizontal();
|
||
|
if (
|
||
|
(m
|
||
|
? ((p.width = t.maxWidth), (p.height = a ? 10 : 0))
|
||
|
: ((p.width = a ? 10 : 0), (p.height = t.maxHeight)),
|
||
|
a)
|
||
|
)
|
||
|
if (((r.font = f), m)) {
|
||
|
var v = (t.lineWidths = [0]),
|
||
|
b = t.legendItems.length ? d + i.padding : 0;
|
||
|
(r.textAlign = "left"),
|
||
|
(r.textBaseline = "top"),
|
||
|
o.each(t.legendItems, function (e, n) {
|
||
|
var a = l(i, d) + d / 2 + r.measureText(e.text).width;
|
||
|
v[v.length - 1] + a + i.padding >= t.width &&
|
||
|
((b += d + i.padding), (v[v.length] = t.left)),
|
||
|
(g[n] = { left: 0, top: 0, width: a, height: d }),
|
||
|
(v[v.length - 1] += a + i.padding);
|
||
|
}),
|
||
|
(p.height += b);
|
||
|
} else {
|
||
|
var x = i.padding,
|
||
|
y = (t.columnWidths = []),
|
||
|
k = i.padding,
|
||
|
M = 0,
|
||
|
w = 0,
|
||
|
S = d + x;
|
||
|
o.each(t.legendItems, function (t, e) {
|
||
|
var n = l(i, d) + d / 2 + r.measureText(t.text).width;
|
||
|
w + S > p.height &&
|
||
|
((k += M + i.padding), y.push(M), (M = 0), (w = 0)),
|
||
|
(M = Math.max(M, n)),
|
||
|
(w += S),
|
||
|
(g[e] = { left: 0, top: 0, width: n, height: d });
|
||
|
}),
|
||
|
(k += M),
|
||
|
y.push(M),
|
||
|
(p.width += k);
|
||
|
}
|
||
|
(t.width = p.width), (t.height = p.height);
|
||
|
},
|
||
|
afterFit: s,
|
||
|
isHorizontal: function () {
|
||
|
return (
|
||
|
"top" === this.options.position ||
|
||
|
"bottom" === this.options.position
|
||
|
);
|
||
|
},
|
||
|
draw: function () {
|
||
|
var t = this,
|
||
|
e = t.options,
|
||
|
i = e.labels,
|
||
|
a = n.global,
|
||
|
r = a.elements.line,
|
||
|
s = t.width,
|
||
|
u = t.lineWidths;
|
||
|
if (e.display) {
|
||
|
var d,
|
||
|
c = t.ctx,
|
||
|
h = o.valueOrDefault,
|
||
|
f = h(i.fontColor, a.defaultFontColor),
|
||
|
g = h(i.fontSize, a.defaultFontSize),
|
||
|
p = h(i.fontStyle, a.defaultFontStyle),
|
||
|
m = h(i.fontFamily, a.defaultFontFamily),
|
||
|
v = o.fontString(g, p, m);
|
||
|
(c.textAlign = "left"),
|
||
|
(c.textBaseline = "middle"),
|
||
|
(c.lineWidth = 0.5),
|
||
|
(c.strokeStyle = f),
|
||
|
(c.fillStyle = f),
|
||
|
(c.font = v);
|
||
|
var b = l(i, g),
|
||
|
x = t.legendHitBoxes,
|
||
|
y = t.isHorizontal();
|
||
|
d = y
|
||
|
? {
|
||
|
x: t.left + (s - u[0]) / 2,
|
||
|
y: t.top + i.padding,
|
||
|
line: 0,
|
||
|
}
|
||
|
: { x: t.left + i.padding, y: t.top + i.padding, line: 0 };
|
||
|
var k = g + i.padding;
|
||
|
o.each(t.legendItems, function (n, l) {
|
||
|
var f,
|
||
|
p,
|
||
|
m,
|
||
|
v,
|
||
|
M,
|
||
|
w = c.measureText(n.text).width,
|
||
|
S = b + g / 2 + w,
|
||
|
C = d.x,
|
||
|
_ = d.y;
|
||
|
y
|
||
|
? C + S >= s &&
|
||
|
((_ = d.y += k),
|
||
|
d.line++,
|
||
|
(C = d.x = t.left + (s - u[d.line]) / 2))
|
||
|
: _ + k > t.bottom &&
|
||
|
((C = d.x = C + t.columnWidths[d.line] + i.padding),
|
||
|
(_ = d.y = t.top + i.padding),
|
||
|
d.line++),
|
||
|
(function (t, i, n) {
|
||
|
if (!(isNaN(b) || b <= 0)) {
|
||
|
c.save(),
|
||
|
(c.fillStyle = h(n.fillStyle, a.defaultColor)),
|
||
|
(c.lineCap = h(n.lineCap, r.borderCapStyle)),
|
||
|
(c.lineDashOffset = h(
|
||
|
n.lineDashOffset,
|
||
|
r.borderDashOffset
|
||
|
)),
|
||
|
(c.lineJoin = h(n.lineJoin, r.borderJoinStyle)),
|
||
|
(c.lineWidth = h(n.lineWidth, r.borderWidth)),
|
||
|
(c.strokeStyle = h(n.strokeStyle, a.defaultColor));
|
||
|
var s = 0 === h(n.lineWidth, r.borderWidth);
|
||
|
if (
|
||
|
(c.setLineDash &&
|
||
|
c.setLineDash(h(n.lineDash, r.borderDash)),
|
||
|
e.labels && e.labels.usePointStyle)
|
||
|
) {
|
||
|
var l = (g * Math.SQRT2) / 2,
|
||
|
u = l / Math.SQRT2,
|
||
|
d = t + u,
|
||
|
f = i + u;
|
||
|
o.canvas.drawPoint(c, n.pointStyle, l, d, f);
|
||
|
} else
|
||
|
s || c.strokeRect(t, i, b, g), c.fillRect(t, i, b, g);
|
||
|
c.restore();
|
||
|
}
|
||
|
})(C, _, n),
|
||
|
(x[l].left = C),
|
||
|
(x[l].top = _),
|
||
|
(f = n),
|
||
|
(p = w),
|
||
|
(v = b + (m = g / 2) + C),
|
||
|
(M = _ + m),
|
||
|
c.fillText(f.text, v, M),
|
||
|
f.hidden &&
|
||
|
(c.beginPath(),
|
||
|
(c.lineWidth = 2),
|
||
|
c.moveTo(v, M),
|
||
|
c.lineTo(v + p, M),
|
||
|
c.stroke()),
|
||
|
y ? (d.x += S + i.padding) : (d.y += k);
|
||
|
});
|
||
|
}
|
||
|
},
|
||
|
handleEvent: function (t) {
|
||
|
var e = this,
|
||
|
i = e.options,
|
||
|
n = "mouseup" === t.type ? "click" : t.type,
|
||
|
a = !1;
|
||
|
if ("mousemove" === n) {
|
||
|
if (!i.onHover) return;
|
||
|
} else {
|
||
|
if ("click" !== n) return;
|
||
|
if (!i.onClick) return;
|
||
|
}
|
||
|
var o = t.x,
|
||
|
r = t.y;
|
||
|
if (o >= e.left && o <= e.right && r >= e.top && r <= e.bottom)
|
||
|
for (var s = e.legendHitBoxes, l = 0; l < s.length; ++l) {
|
||
|
var u = s[l];
|
||
|
if (
|
||
|
o >= u.left &&
|
||
|
o <= u.left + u.width &&
|
||
|
r >= u.top &&
|
||
|
r <= u.top + u.height
|
||
|
) {
|
||
|
if ("click" === n) {
|
||
|
i.onClick.call(e, t.native, e.legendItems[l]), (a = !0);
|
||
|
break;
|
||
|
}
|
||
|
if ("mousemove" === n) {
|
||
|
i.onHover.call(e, t.native, e.legendItems[l]), (a = !0);
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return a;
|
||
|
},
|
||
|
});
|
||
|
function d(t, e) {
|
||
|
var i = new u({ ctx: t.ctx, options: e, chart: t });
|
||
|
r.configure(t, i, e), r.addBox(t, i), (t.legend = i);
|
||
|
}
|
||
|
e.exports = {
|
||
|
id: "legend",
|
||
|
_element: u,
|
||
|
beforeInit: function (t) {
|
||
|
var e = t.options.legend;
|
||
|
e && d(t, e);
|
||
|
},
|
||
|
beforeUpdate: function (t) {
|
||
|
var e = t.options.legend,
|
||
|
i = t.legend;
|
||
|
e
|
||
|
? (o.mergeIf(e, n.global.legend),
|
||
|
i ? (r.configure(t, i, e), (i.options = e)) : d(t, e))
|
||
|
: i && (r.removeBox(t, i), delete t.legend);
|
||
|
},
|
||
|
afterEvent: function (t, e) {
|
||
|
var i = t.legend;
|
||
|
i && i.handleEvent(e);
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{ 25: 25, 26: 26, 30: 30, 45: 45 },
|
||
|
],
|
||
|
52: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(26),
|
||
|
o = t(45),
|
||
|
r = t(30),
|
||
|
s = o.noop;
|
||
|
n._set("global", {
|
||
|
title: {
|
||
|
display: !1,
|
||
|
fontStyle: "bold",
|
||
|
fullWidth: !0,
|
||
|
lineHeight: 1.2,
|
||
|
padding: 10,
|
||
|
position: "top",
|
||
|
text: "",
|
||
|
weight: 2e3,
|
||
|
},
|
||
|
});
|
||
|
var l = a.extend({
|
||
|
initialize: function (t) {
|
||
|
o.extend(this, t), (this.legendHitBoxes = []);
|
||
|
},
|
||
|
beforeUpdate: s,
|
||
|
update: function (t, e, i) {
|
||
|
var n = this;
|
||
|
return (
|
||
|
n.beforeUpdate(),
|
||
|
(n.maxWidth = t),
|
||
|
(n.maxHeight = e),
|
||
|
(n.margins = i),
|
||
|
n.beforeSetDimensions(),
|
||
|
n.setDimensions(),
|
||
|
n.afterSetDimensions(),
|
||
|
n.beforeBuildLabels(),
|
||
|
n.buildLabels(),
|
||
|
n.afterBuildLabels(),
|
||
|
n.beforeFit(),
|
||
|
n.fit(),
|
||
|
n.afterFit(),
|
||
|
n.afterUpdate(),
|
||
|
n.minSize
|
||
|
);
|
||
|
},
|
||
|
afterUpdate: s,
|
||
|
beforeSetDimensions: s,
|
||
|
setDimensions: function () {
|
||
|
var t = this;
|
||
|
t.isHorizontal()
|
||
|
? ((t.width = t.maxWidth), (t.left = 0), (t.right = t.width))
|
||
|
: ((t.height = t.maxHeight),
|
||
|
(t.top = 0),
|
||
|
(t.bottom = t.height)),
|
||
|
(t.paddingLeft = 0),
|
||
|
(t.paddingTop = 0),
|
||
|
(t.paddingRight = 0),
|
||
|
(t.paddingBottom = 0),
|
||
|
(t.minSize = { width: 0, height: 0 });
|
||
|
},
|
||
|
afterSetDimensions: s,
|
||
|
beforeBuildLabels: s,
|
||
|
buildLabels: s,
|
||
|
afterBuildLabels: s,
|
||
|
beforeFit: s,
|
||
|
fit: function () {
|
||
|
var t = this,
|
||
|
e = o.valueOrDefault,
|
||
|
i = t.options,
|
||
|
a = i.display,
|
||
|
r = e(i.fontSize, n.global.defaultFontSize),
|
||
|
s = t.minSize,
|
||
|
l = o.isArray(i.text) ? i.text.length : 1,
|
||
|
u = o.options.toLineHeight(i.lineHeight, r),
|
||
|
d = a ? l * u + 2 * i.padding : 0;
|
||
|
t.isHorizontal()
|
||
|
? ((s.width = t.maxWidth), (s.height = d))
|
||
|
: ((s.width = d), (s.height = t.maxHeight)),
|
||
|
(t.width = s.width),
|
||
|
(t.height = s.height);
|
||
|
},
|
||
|
afterFit: s,
|
||
|
isHorizontal: function () {
|
||
|
var t = this.options.position;
|
||
|
return "top" === t || "bottom" === t;
|
||
|
},
|
||
|
draw: function () {
|
||
|
var t = this,
|
||
|
e = t.ctx,
|
||
|
i = o.valueOrDefault,
|
||
|
a = t.options,
|
||
|
r = n.global;
|
||
|
if (a.display) {
|
||
|
var s,
|
||
|
l,
|
||
|
u,
|
||
|
d = i(a.fontSize, r.defaultFontSize),
|
||
|
c = i(a.fontStyle, r.defaultFontStyle),
|
||
|
h = i(a.fontFamily, r.defaultFontFamily),
|
||
|
f = o.fontString(d, c, h),
|
||
|
g = o.options.toLineHeight(a.lineHeight, d),
|
||
|
p = g / 2 + a.padding,
|
||
|
m = 0,
|
||
|
v = t.top,
|
||
|
b = t.left,
|
||
|
x = t.bottom,
|
||
|
y = t.right;
|
||
|
(e.fillStyle = i(a.fontColor, r.defaultFontColor)),
|
||
|
(e.font = f),
|
||
|
t.isHorizontal()
|
||
|
? ((l = b + (y - b) / 2), (u = v + p), (s = y - b))
|
||
|
: ((l = "left" === a.position ? b + p : y - p),
|
||
|
(u = v + (x - v) / 2),
|
||
|
(s = x - v),
|
||
|
(m = Math.PI * ("left" === a.position ? -0.5 : 0.5))),
|
||
|
e.save(),
|
||
|
e.translate(l, u),
|
||
|
e.rotate(m),
|
||
|
(e.textAlign = "center"),
|
||
|
(e.textBaseline = "middle");
|
||
|
var k = a.text;
|
||
|
if (o.isArray(k))
|
||
|
for (var M = 0, w = 0; w < k.length; ++w)
|
||
|
e.fillText(k[w], 0, M, s), (M += g);
|
||
|
else e.fillText(k, 0, 0, s);
|
||
|
e.restore();
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
function u(t, e) {
|
||
|
var i = new l({ ctx: t.ctx, options: e, chart: t });
|
||
|
r.configure(t, i, e), r.addBox(t, i), (t.titleBlock = i);
|
||
|
}
|
||
|
e.exports = {
|
||
|
id: "title",
|
||
|
_element: l,
|
||
|
beforeInit: function (t) {
|
||
|
var e = t.options.title;
|
||
|
e && u(t, e);
|
||
|
},
|
||
|
beforeUpdate: function (t) {
|
||
|
var e = t.options.title,
|
||
|
i = t.titleBlock;
|
||
|
e
|
||
|
? (o.mergeIf(e, n.global.title),
|
||
|
i ? (r.configure(t, i, e), (i.options = e)) : u(t, e))
|
||
|
: i && (r.removeBox(t, i), delete t.titleBlock);
|
||
|
},
|
||
|
};
|
||
|
},
|
||
|
{ 25: 25, 26: 26, 30: 30, 45: 45 },
|
||
|
],
|
||
|
53: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
e.exports = function (t) {
|
||
|
var e = t.Scale.extend({
|
||
|
getLabels: function () {
|
||
|
var t = this.chart.data;
|
||
|
return (
|
||
|
this.options.labels ||
|
||
|
(this.isHorizontal() ? t.xLabels : t.yLabels) ||
|
||
|
t.labels
|
||
|
);
|
||
|
},
|
||
|
determineDataLimits: function () {
|
||
|
var t,
|
||
|
e = this,
|
||
|
i = e.getLabels();
|
||
|
(e.minIndex = 0),
|
||
|
(e.maxIndex = i.length - 1),
|
||
|
void 0 !== e.options.ticks.min &&
|
||
|
((t = i.indexOf(e.options.ticks.min)),
|
||
|
(e.minIndex = -1 !== t ? t : e.minIndex)),
|
||
|
void 0 !== e.options.ticks.max &&
|
||
|
((t = i.indexOf(e.options.ticks.max)),
|
||
|
(e.maxIndex = -1 !== t ? t : e.maxIndex)),
|
||
|
(e.min = i[e.minIndex]),
|
||
|
(e.max = i[e.maxIndex]);
|
||
|
},
|
||
|
buildTicks: function () {
|
||
|
var t = this,
|
||
|
e = t.getLabels();
|
||
|
t.ticks =
|
||
|
0 === t.minIndex && t.maxIndex === e.length - 1
|
||
|
? e
|
||
|
: e.slice(t.minIndex, t.maxIndex + 1);
|
||
|
},
|
||
|
getLabelForIndex: function (t, e) {
|
||
|
var i = this,
|
||
|
n = i.chart.data,
|
||
|
a = i.isHorizontal();
|
||
|
return n.yLabels && !a
|
||
|
? i.getRightValue(n.datasets[e].data[t])
|
||
|
: i.ticks[t - i.minIndex];
|
||
|
},
|
||
|
getPixelForValue: function (t, e) {
|
||
|
var i,
|
||
|
n = this,
|
||
|
a = n.options.offset,
|
||
|
o = Math.max(n.maxIndex + 1 - n.minIndex - (a ? 0 : 1), 1);
|
||
|
if (
|
||
|
(null != t && (i = n.isHorizontal() ? t.x : t.y),
|
||
|
void 0 !== i || (void 0 !== t && isNaN(e)))
|
||
|
) {
|
||
|
t = i || t;
|
||
|
var r = n.getLabels().indexOf(t);
|
||
|
e = -1 !== r ? r : e;
|
||
|
}
|
||
|
if (n.isHorizontal()) {
|
||
|
var s = n.width / o,
|
||
|
l = s * (e - n.minIndex);
|
||
|
return a && (l += s / 2), n.left + Math.round(l);
|
||
|
}
|
||
|
var u = n.height / o,
|
||
|
d = u * (e - n.minIndex);
|
||
|
return a && (d += u / 2), n.top + Math.round(d);
|
||
|
},
|
||
|
getPixelForTick: function (t) {
|
||
|
return this.getPixelForValue(
|
||
|
this.ticks[t],
|
||
|
t + this.minIndex,
|
||
|
null
|
||
|
);
|
||
|
},
|
||
|
getValueForPixel: function (t) {
|
||
|
var e = this,
|
||
|
i = e.options.offset,
|
||
|
n = Math.max(e._ticks.length - (i ? 0 : 1), 1),
|
||
|
a = e.isHorizontal(),
|
||
|
o = (a ? e.width : e.height) / n;
|
||
|
return (
|
||
|
(t -= a ? e.left : e.top),
|
||
|
i && (t -= o / 2),
|
||
|
(t <= 0 ? 0 : Math.round(t / o)) + e.minIndex
|
||
|
);
|
||
|
},
|
||
|
getBasePixel: function () {
|
||
|
return this.bottom;
|
||
|
},
|
||
|
});
|
||
|
t.scaleService.registerScaleType("category", e, {
|
||
|
position: "bottom",
|
||
|
});
|
||
|
};
|
||
|
},
|
||
|
{},
|
||
|
],
|
||
|
54: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(45),
|
||
|
o = t(34);
|
||
|
e.exports = function (t) {
|
||
|
var e = {
|
||
|
position: "left",
|
||
|
ticks: { callback: o.formatters.linear },
|
||
|
},
|
||
|
i = t.LinearScaleBase.extend({
|
||
|
determineDataLimits: function () {
|
||
|
var t = this,
|
||
|
e = t.options,
|
||
|
i = t.chart,
|
||
|
n = i.data.datasets,
|
||
|
o = t.isHorizontal();
|
||
|
function r(e) {
|
||
|
return o ? e.xAxisID === t.id : e.yAxisID === t.id;
|
||
|
}
|
||
|
(t.min = null), (t.max = null);
|
||
|
var s = e.stacked;
|
||
|
if (
|
||
|
(void 0 === s &&
|
||
|
a.each(n, function (t, e) {
|
||
|
if (!s) {
|
||
|
var n = i.getDatasetMeta(e);
|
||
|
i.isDatasetVisible(e) &&
|
||
|
r(n) &&
|
||
|
void 0 !== n.stack &&
|
||
|
(s = !0);
|
||
|
}
|
||
|
}),
|
||
|
e.stacked || s)
|
||
|
) {
|
||
|
var l = {};
|
||
|
a.each(n, function (n, o) {
|
||
|
var s = i.getDatasetMeta(o),
|
||
|
u = [
|
||
|
s.type,
|
||
|
void 0 === e.stacked && void 0 === s.stack ? o : "",
|
||
|
s.stack,
|
||
|
].join(".");
|
||
|
void 0 === l[u] &&
|
||
|
(l[u] = { positiveValues: [], negativeValues: [] });
|
||
|
var d = l[u].positiveValues,
|
||
|
c = l[u].negativeValues;
|
||
|
i.isDatasetVisible(o) &&
|
||
|
r(s) &&
|
||
|
a.each(n.data, function (i, n) {
|
||
|
var a = +t.getRightValue(i);
|
||
|
isNaN(a) ||
|
||
|
s.data[n].hidden ||
|
||
|
((d[n] = d[n] || 0),
|
||
|
(c[n] = c[n] || 0),
|
||
|
e.relativePoints
|
||
|
? (d[n] = 100)
|
||
|
: a < 0
|
||
|
? (c[n] += a)
|
||
|
: (d[n] += a));
|
||
|
});
|
||
|
}),
|
||
|
a.each(l, function (e) {
|
||
|
var i = e.positiveValues.concat(e.negativeValues),
|
||
|
n = a.min(i),
|
||
|
o = a.max(i);
|
||
|
(t.min = null === t.min ? n : Math.min(t.min, n)),
|
||
|
(t.max = null === t.max ? o : Math.max(t.max, o));
|
||
|
});
|
||
|
} else
|
||
|
a.each(n, function (e, n) {
|
||
|
var o = i.getDatasetMeta(n);
|
||
|
i.isDatasetVisible(n) &&
|
||
|
r(o) &&
|
||
|
a.each(e.data, function (e, i) {
|
||
|
var n = +t.getRightValue(e);
|
||
|
isNaN(n) ||
|
||
|
o.data[i].hidden ||
|
||
|
(null === t.min
|
||
|
? (t.min = n)
|
||
|
: n < t.min && (t.min = n),
|
||
|
null === t.max
|
||
|
? (t.max = n)
|
||
|
: n > t.max && (t.max = n));
|
||
|
});
|
||
|
});
|
||
|
(t.min = isFinite(t.min) && !isNaN(t.min) ? t.min : 0),
|
||
|
(t.max = isFinite(t.max) && !isNaN(t.max) ? t.max : 1),
|
||
|
this.handleTickRangeOptions();
|
||
|
},
|
||
|
getTickLimit: function () {
|
||
|
var t,
|
||
|
e = this.options.ticks;
|
||
|
if (this.isHorizontal())
|
||
|
t = Math.min(
|
||
|
e.maxTicksLimit ? e.maxTicksLimit : 11,
|
||
|
Math.ceil(this.width / 50)
|
||
|
);
|
||
|
else {
|
||
|
var i = a.valueOrDefault(
|
||
|
e.fontSize,
|
||
|
n.global.defaultFontSize
|
||
|
);
|
||
|
t = Math.min(
|
||
|
e.maxTicksLimit ? e.maxTicksLimit : 11,
|
||
|
Math.ceil(this.height / (2 * i))
|
||
|
);
|
||
|
}
|
||
|
return t;
|
||
|
},
|
||
|
handleDirectionalChanges: function () {
|
||
|
this.isHorizontal() || this.ticks.reverse();
|
||
|
},
|
||
|
getLabelForIndex: function (t, e) {
|
||
|
return +this.getRightValue(
|
||
|
this.chart.data.datasets[e].data[t]
|
||
|
);
|
||
|
},
|
||
|
getPixelForValue: function (t) {
|
||
|
var e = this,
|
||
|
i = e.start,
|
||
|
n = +e.getRightValue(t),
|
||
|
a = e.end - i;
|
||
|
return e.isHorizontal()
|
||
|
? e.left + (e.width / a) * (n - i)
|
||
|
: e.bottom - (e.height / a) * (n - i);
|
||
|
},
|
||
|
getValueForPixel: function (t) {
|
||
|
var e = this,
|
||
|
i = e.isHorizontal(),
|
||
|
n = i ? e.width : e.height,
|
||
|
a = (i ? t - e.left : e.bottom - t) / n;
|
||
|
return e.start + (e.end - e.start) * a;
|
||
|
},
|
||
|
getPixelForTick: function (t) {
|
||
|
return this.getPixelForValue(this.ticksAsNumbers[t]);
|
||
|
},
|
||
|
});
|
||
|
t.scaleService.registerScaleType("linear", i, e);
|
||
|
};
|
||
|
},
|
||
|
{ 25: 25, 34: 34, 45: 45 },
|
||
|
],
|
||
|
55: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45);
|
||
|
e.exports = function (t) {
|
||
|
var e = n.noop;
|
||
|
t.LinearScaleBase = t.Scale.extend({
|
||
|
getRightValue: function (e) {
|
||
|
return "string" == typeof e
|
||
|
? +e
|
||
|
: t.Scale.prototype.getRightValue.call(this, e);
|
||
|
},
|
||
|
handleTickRangeOptions: function () {
|
||
|
var t = this,
|
||
|
e = t.options.ticks;
|
||
|
if (e.beginAtZero) {
|
||
|
var i = n.sign(t.min),
|
||
|
a = n.sign(t.max);
|
||
|
i < 0 && a < 0 ? (t.max = 0) : i > 0 && a > 0 && (t.min = 0);
|
||
|
}
|
||
|
var o = void 0 !== e.min || void 0 !== e.suggestedMin,
|
||
|
r = void 0 !== e.max || void 0 !== e.suggestedMax;
|
||
|
void 0 !== e.min
|
||
|
? (t.min = e.min)
|
||
|
: void 0 !== e.suggestedMin &&
|
||
|
(null === t.min
|
||
|
? (t.min = e.suggestedMin)
|
||
|
: (t.min = Math.min(t.min, e.suggestedMin))),
|
||
|
void 0 !== e.max
|
||
|
? (t.max = e.max)
|
||
|
: void 0 !== e.suggestedMax &&
|
||
|
(null === t.max
|
||
|
? (t.max = e.suggestedMax)
|
||
|
: (t.max = Math.max(t.max, e.suggestedMax))),
|
||
|
o !== r &&
|
||
|
t.min >= t.max &&
|
||
|
(o ? (t.max = t.min + 1) : (t.min = t.max - 1)),
|
||
|
t.min === t.max && (t.max++, e.beginAtZero || t.min--);
|
||
|
},
|
||
|
getTickLimit: e,
|
||
|
handleDirectionalChanges: e,
|
||
|
buildTicks: function () {
|
||
|
var t = this,
|
||
|
e = t.options.ticks,
|
||
|
i = t.getTickLimit(),
|
||
|
a = {
|
||
|
maxTicks: (i = Math.max(2, i)),
|
||
|
min: e.min,
|
||
|
max: e.max,
|
||
|
stepSize: n.valueOrDefault(e.fixedStepSize, e.stepSize),
|
||
|
},
|
||
|
o = (t.ticks = (function (t, e) {
|
||
|
var i,
|
||
|
a = [];
|
||
|
if (t.stepSize && t.stepSize > 0) i = t.stepSize;
|
||
|
else {
|
||
|
var o = n.niceNum(e.max - e.min, !1);
|
||
|
i = n.niceNum(o / (t.maxTicks - 1), !0);
|
||
|
}
|
||
|
var r = Math.floor(e.min / i) * i,
|
||
|
s = Math.ceil(e.max / i) * i;
|
||
|
t.min &&
|
||
|
t.max &&
|
||
|
t.stepSize &&
|
||
|
n.almostWhole((t.max - t.min) / t.stepSize, i / 1e3) &&
|
||
|
((r = t.min), (s = t.max));
|
||
|
var l = (s - r) / i;
|
||
|
l = n.almostEquals(l, Math.round(l), i / 1e3)
|
||
|
? Math.round(l)
|
||
|
: Math.ceil(l);
|
||
|
var u = 1;
|
||
|
i < 1 &&
|
||
|
((u = Math.pow(10, i.toString().length - 2)),
|
||
|
(r = Math.round(r * u) / u),
|
||
|
(s = Math.round(s * u) / u)),
|
||
|
a.push(void 0 !== t.min ? t.min : r);
|
||
|
for (var d = 1; d < l; ++d)
|
||
|
a.push(Math.round((r + d * i) * u) / u);
|
||
|
return a.push(void 0 !== t.max ? t.max : s), a;
|
||
|
})(a, t));
|
||
|
t.handleDirectionalChanges(),
|
||
|
(t.max = n.max(o)),
|
||
|
(t.min = n.min(o)),
|
||
|
e.reverse
|
||
|
? (o.reverse(), (t.start = t.max), (t.end = t.min))
|
||
|
: ((t.start = t.min), (t.end = t.max));
|
||
|
},
|
||
|
convertTicksToLabels: function () {
|
||
|
var e = this;
|
||
|
(e.ticksAsNumbers = e.ticks.slice()),
|
||
|
(e.zeroLineIndex = e.ticks.indexOf(0)),
|
||
|
t.Scale.prototype.convertTicksToLabels.call(e);
|
||
|
},
|
||
|
});
|
||
|
};
|
||
|
},
|
||
|
{ 45: 45 },
|
||
|
],
|
||
|
56: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(45),
|
||
|
a = t(34);
|
||
|
e.exports = function (t) {
|
||
|
var e = {
|
||
|
position: "left",
|
||
|
ticks: { callback: a.formatters.logarithmic },
|
||
|
},
|
||
|
i = t.Scale.extend({
|
||
|
determineDataLimits: function () {
|
||
|
var t = this,
|
||
|
e = t.options,
|
||
|
i = t.chart,
|
||
|
a = i.data.datasets,
|
||
|
o = t.isHorizontal();
|
||
|
function r(e) {
|
||
|
return o ? e.xAxisID === t.id : e.yAxisID === t.id;
|
||
|
}
|
||
|
(t.min = null), (t.max = null), (t.minNotZero = null);
|
||
|
var s = e.stacked;
|
||
|
if (
|
||
|
(void 0 === s &&
|
||
|
n.each(a, function (t, e) {
|
||
|
if (!s) {
|
||
|
var n = i.getDatasetMeta(e);
|
||
|
i.isDatasetVisible(e) &&
|
||
|
r(n) &&
|
||
|
void 0 !== n.stack &&
|
||
|
(s = !0);
|
||
|
}
|
||
|
}),
|
||
|
e.stacked || s)
|
||
|
) {
|
||
|
var l = {};
|
||
|
n.each(a, function (a, o) {
|
||
|
var s = i.getDatasetMeta(o),
|
||
|
u = [
|
||
|
s.type,
|
||
|
void 0 === e.stacked && void 0 === s.stack ? o : "",
|
||
|
s.stack,
|
||
|
].join(".");
|
||
|
i.isDatasetVisible(o) &&
|
||
|
r(s) &&
|
||
|
(void 0 === l[u] && (l[u] = []),
|
||
|
n.each(a.data, function (e, i) {
|
||
|
var n = l[u],
|
||
|
a = +t.getRightValue(e);
|
||
|
isNaN(a) ||
|
||
|
s.data[i].hidden ||
|
||
|
a < 0 ||
|
||
|
((n[i] = n[i] || 0), (n[i] += a));
|
||
|
}));
|
||
|
}),
|
||
|
n.each(l, function (e) {
|
||
|
if (e.length > 0) {
|
||
|
var i = n.min(e),
|
||
|
a = n.max(e);
|
||
|
(t.min = null === t.min ? i : Math.min(t.min, i)),
|
||
|
(t.max = null === t.max ? a : Math.max(t.max, a));
|
||
|
}
|
||
|
});
|
||
|
} else
|
||
|
n.each(a, function (e, a) {
|
||
|
var o = i.getDatasetMeta(a);
|
||
|
i.isDatasetVisible(a) &&
|
||
|
r(o) &&
|
||
|
n.each(e.data, function (e, i) {
|
||
|
var n = +t.getRightValue(e);
|
||
|
isNaN(n) ||
|
||
|
o.data[i].hidden ||
|
||
|
n < 0 ||
|
||
|
(null === t.min
|
||
|
? (t.min = n)
|
||
|
: n < t.min && (t.min = n),
|
||
|
null === t.max
|
||
|
? (t.max = n)
|
||
|
: n > t.max && (t.max = n),
|
||
|
0 !== n &&
|
||
|
(null === t.minNotZero || n < t.minNotZero) &&
|
||
|
(t.minNotZero = n));
|
||
|
});
|
||
|
});
|
||
|
this.handleTickRangeOptions();
|
||
|
},
|
||
|
handleTickRangeOptions: function () {
|
||
|
var t = this,
|
||
|
e = t.options.ticks,
|
||
|
i = n.valueOrDefault;
|
||
|
(t.min = i(e.min, t.min)),
|
||
|
(t.max = i(e.max, t.max)),
|
||
|
t.min === t.max &&
|
||
|
(0 !== t.min && null !== t.min
|
||
|
? ((t.min = Math.pow(
|
||
|
10,
|
||
|
Math.floor(n.log10(t.min)) - 1
|
||
|
)),
|
||
|
(t.max = Math.pow(
|
||
|
10,
|
||
|
Math.floor(n.log10(t.max)) + 1
|
||
|
)))
|
||
|
: ((t.min = 1), (t.max = 10))),
|
||
|
null === t.min &&
|
||
|
(t.min = Math.pow(10, Math.floor(n.log10(t.max)) - 1)),
|
||
|
null === t.max &&
|
||
|
(t.max =
|
||
|
0 !== t.min
|
||
|
? Math.pow(10, Math.floor(n.log10(t.min)) + 1)
|
||
|
: 10),
|
||
|
null === t.minNotZero &&
|
||
|
(t.min > 0
|
||
|
? (t.minNotZero = t.min)
|
||
|
: t.max < 1
|
||
|
? (t.minNotZero = Math.pow(
|
||
|
10,
|
||
|
Math.floor(n.log10(t.max))
|
||
|
))
|
||
|
: (t.minNotZero = 1));
|
||
|
},
|
||
|
buildTicks: function () {
|
||
|
var t = this,
|
||
|
e = t.options.ticks,
|
||
|
i = !t.isHorizontal(),
|
||
|
a = { min: e.min, max: e.max },
|
||
|
o = (t.ticks = (function (t, e) {
|
||
|
var i,
|
||
|
a,
|
||
|
o = [],
|
||
|
r = n.valueOrDefault,
|
||
|
s = r(t.min, Math.pow(10, Math.floor(n.log10(e.min)))),
|
||
|
l = Math.floor(n.log10(e.max)),
|
||
|
u = Math.ceil(e.max / Math.pow(10, l));
|
||
|
0 === s
|
||
|
? ((i = Math.floor(n.log10(e.minNotZero))),
|
||
|
(a = Math.floor(e.minNotZero / Math.pow(10, i))),
|
||
|
o.push(s),
|
||
|
(s = a * Math.pow(10, i)))
|
||
|
: ((i = Math.floor(n.log10(s))),
|
||
|
(a = Math.floor(s / Math.pow(10, i))));
|
||
|
for (
|
||
|
var d = i < 0 ? Math.pow(10, Math.abs(i)) : 1;
|
||
|
o.push(s),
|
||
|
10 == ++a && ((a = 1), (d = ++i >= 0 ? 1 : d)),
|
||
|
(s = Math.round(a * Math.pow(10, i) * d) / d),
|
||
|
i < l || (i === l && a < u);
|
||
|
|
||
|
);
|
||
|
var c = r(t.max, s);
|
||
|
return o.push(c), o;
|
||
|
})(a, t));
|
||
|
(t.max = n.max(o)),
|
||
|
(t.min = n.min(o)),
|
||
|
e.reverse
|
||
|
? ((i = !i), (t.start = t.max), (t.end = t.min))
|
||
|
: ((t.start = t.min), (t.end = t.max)),
|
||
|
i && o.reverse();
|
||
|
},
|
||
|
convertTicksToLabels: function () {
|
||
|
(this.tickValues = this.ticks.slice()),
|
||
|
t.Scale.prototype.convertTicksToLabels.call(this);
|
||
|
},
|
||
|
getLabelForIndex: function (t, e) {
|
||
|
return +this.getRightValue(
|
||
|
this.chart.data.datasets[e].data[t]
|
||
|
);
|
||
|
},
|
||
|
getPixelForTick: function (t) {
|
||
|
return this.getPixelForValue(this.tickValues[t]);
|
||
|
},
|
||
|
_getFirstTickValue: function (t) {
|
||
|
var e = Math.floor(n.log10(t));
|
||
|
return Math.floor(t / Math.pow(10, e)) * Math.pow(10, e);
|
||
|
},
|
||
|
getPixelForValue: function (e) {
|
||
|
var i,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s,
|
||
|
l = this,
|
||
|
u = l.options.ticks.reverse,
|
||
|
d = n.log10,
|
||
|
c = l._getFirstTickValue(l.minNotZero),
|
||
|
h = 0;
|
||
|
return (
|
||
|
(e = +l.getRightValue(e)),
|
||
|
u
|
||
|
? ((o = l.end), (r = l.start), (s = -1))
|
||
|
: ((o = l.start), (r = l.end), (s = 1)),
|
||
|
l.isHorizontal()
|
||
|
? ((i = l.width), (a = u ? l.right : l.left))
|
||
|
: ((i = l.height), (s *= -1), (a = u ? l.top : l.bottom)),
|
||
|
e !== o &&
|
||
|
(0 === o &&
|
||
|
((i -= h =
|
||
|
n.getValueOrDefault(
|
||
|
l.options.ticks.fontSize,
|
||
|
t.defaults.global.defaultFontSize
|
||
|
)),
|
||
|
(o = c)),
|
||
|
0 !== e && (h += (i / (d(r) - d(o))) * (d(e) - d(o))),
|
||
|
(a += s * h)),
|
||
|
a
|
||
|
);
|
||
|
},
|
||
|
getValueForPixel: function (e) {
|
||
|
var i,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s = this,
|
||
|
l = s.options.ticks.reverse,
|
||
|
u = n.log10,
|
||
|
d = s._getFirstTickValue(s.minNotZero);
|
||
|
if (
|
||
|
(l
|
||
|
? ((a = s.end), (o = s.start))
|
||
|
: ((a = s.start), (o = s.end)),
|
||
|
s.isHorizontal()
|
||
|
? ((i = s.width), (r = l ? s.right - e : e - s.left))
|
||
|
: ((i = s.height), (r = l ? e - s.top : s.bottom - e)),
|
||
|
r !== a)
|
||
|
) {
|
||
|
if (0 === a) {
|
||
|
var c = n.getValueOrDefault(
|
||
|
s.options.ticks.fontSize,
|
||
|
t.defaults.global.defaultFontSize
|
||
|
);
|
||
|
(r -= c), (i -= c), (a = d);
|
||
|
}
|
||
|
(r *= u(o) - u(a)), (r /= i), (r = Math.pow(10, u(a) + r));
|
||
|
}
|
||
|
return r;
|
||
|
},
|
||
|
});
|
||
|
t.scaleService.registerScaleType("logarithmic", i, e);
|
||
|
};
|
||
|
},
|
||
|
{ 34: 34, 45: 45 },
|
||
|
],
|
||
|
57: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(25),
|
||
|
a = t(45),
|
||
|
o = t(34);
|
||
|
e.exports = function (t) {
|
||
|
var e = n.global,
|
||
|
i = {
|
||
|
display: !0,
|
||
|
animate: !0,
|
||
|
position: "chartArea",
|
||
|
angleLines: {
|
||
|
display: !0,
|
||
|
color: "rgba(0, 0, 0, 0.1)",
|
||
|
lineWidth: 1,
|
||
|
},
|
||
|
gridLines: { circular: !1 },
|
||
|
ticks: {
|
||
|
showLabelBackdrop: !0,
|
||
|
backdropColor: "rgba(255,255,255,0.75)",
|
||
|
backdropPaddingY: 2,
|
||
|
backdropPaddingX: 2,
|
||
|
callback: o.formatters.linear,
|
||
|
},
|
||
|
pointLabels: {
|
||
|
display: !0,
|
||
|
fontSize: 10,
|
||
|
callback: function (t) {
|
||
|
return t;
|
||
|
},
|
||
|
},
|
||
|
};
|
||
|
function r(t) {
|
||
|
var e = t.options;
|
||
|
return e.angleLines.display || e.pointLabels.display
|
||
|
? t.chart.data.labels.length
|
||
|
: 0;
|
||
|
}
|
||
|
function s(t) {
|
||
|
var i = t.options.pointLabels,
|
||
|
n = a.valueOrDefault(i.fontSize, e.defaultFontSize),
|
||
|
o = a.valueOrDefault(i.fontStyle, e.defaultFontStyle),
|
||
|
r = a.valueOrDefault(i.fontFamily, e.defaultFontFamily);
|
||
|
return {
|
||
|
size: n,
|
||
|
style: o,
|
||
|
family: r,
|
||
|
font: a.fontString(n, o, r),
|
||
|
};
|
||
|
}
|
||
|
function l(t, e, i, n, a) {
|
||
|
return t === n || t === a
|
||
|
? { start: e - i / 2, end: e + i / 2 }
|
||
|
: t < n || t > a
|
||
|
? { start: e - i - 5, end: e }
|
||
|
: { start: e, end: e + i + 5 };
|
||
|
}
|
||
|
function u(t, e, i, n) {
|
||
|
if (a.isArray(e))
|
||
|
for (var o = i.y, r = 1.5 * n, s = 0; s < e.length; ++s)
|
||
|
t.fillText(e[s], i.x, o), (o += r);
|
||
|
else t.fillText(e, i.x, i.y);
|
||
|
}
|
||
|
function d(t) {
|
||
|
return a.isNumber(t) ? t : 0;
|
||
|
}
|
||
|
var c = t.LinearScaleBase.extend({
|
||
|
setDimensions: function () {
|
||
|
var t = this,
|
||
|
i = t.options,
|
||
|
n = i.ticks;
|
||
|
(t.width = t.maxWidth),
|
||
|
(t.height = t.maxHeight),
|
||
|
(t.xCenter = Math.round(t.width / 2)),
|
||
|
(t.yCenter = Math.round(t.height / 2));
|
||
|
var o = a.min([t.height, t.width]),
|
||
|
r = a.valueOrDefault(n.fontSize, e.defaultFontSize);
|
||
|
t.drawingArea = i.display
|
||
|
? o / 2 - (r / 2 + n.backdropPaddingY)
|
||
|
: o / 2;
|
||
|
},
|
||
|
determineDataLimits: function () {
|
||
|
var t = this,
|
||
|
e = t.chart,
|
||
|
i = Number.POSITIVE_INFINITY,
|
||
|
n = Number.NEGATIVE_INFINITY;
|
||
|
a.each(e.data.datasets, function (o, r) {
|
||
|
if (e.isDatasetVisible(r)) {
|
||
|
var s = e.getDatasetMeta(r);
|
||
|
a.each(o.data, function (e, a) {
|
||
|
var o = +t.getRightValue(e);
|
||
|
isNaN(o) ||
|
||
|
s.data[a].hidden ||
|
||
|
((i = Math.min(o, i)), (n = Math.max(o, n)));
|
||
|
});
|
||
|
}
|
||
|
}),
|
||
|
(t.min = i === Number.POSITIVE_INFINITY ? 0 : i),
|
||
|
(t.max = n === Number.NEGATIVE_INFINITY ? 0 : n),
|
||
|
t.handleTickRangeOptions();
|
||
|
},
|
||
|
getTickLimit: function () {
|
||
|
var t = this.options.ticks,
|
||
|
i = a.valueOrDefault(t.fontSize, e.defaultFontSize);
|
||
|
return Math.min(
|
||
|
t.maxTicksLimit ? t.maxTicksLimit : 11,
|
||
|
Math.ceil(this.drawingArea / (1.5 * i))
|
||
|
);
|
||
|
},
|
||
|
convertTicksToLabels: function () {
|
||
|
var e = this;
|
||
|
t.LinearScaleBase.prototype.convertTicksToLabels.call(e),
|
||
|
(e.pointLabels = e.chart.data.labels.map(
|
||
|
e.options.pointLabels.callback,
|
||
|
e
|
||
|
));
|
||
|
},
|
||
|
getLabelForIndex: function (t, e) {
|
||
|
return +this.getRightValue(this.chart.data.datasets[e].data[t]);
|
||
|
},
|
||
|
fit: function () {
|
||
|
var t, e;
|
||
|
this.options.pointLabels.display
|
||
|
? (function (t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
o = s(t),
|
||
|
u = Math.min(t.height / 2, t.width / 2),
|
||
|
d = { r: t.width, l: 0, t: t.height, b: 0 },
|
||
|
c = {};
|
||
|
(t.ctx.font = o.font), (t._pointLabelSizes = []);
|
||
|
var h,
|
||
|
f,
|
||
|
g,
|
||
|
p = r(t);
|
||
|
for (e = 0; e < p; e++) {
|
||
|
(n = t.getPointPosition(e, u)),
|
||
|
(h = t.ctx),
|
||
|
(f = o.size),
|
||
|
(g = t.pointLabels[e] || ""),
|
||
|
(i = a.isArray(g)
|
||
|
? {
|
||
|
w: a.longestText(h, h.font, g),
|
||
|
h: g.length * f + 1.5 * (g.length - 1) * f,
|
||
|
}
|
||
|
: { w: h.measureText(g).width, h: f }),
|
||
|
(t._pointLabelSizes[e] = i);
|
||
|
var m = t.getIndexAngle(e),
|
||
|
v = a.toDegrees(m) % 360,
|
||
|
b = l(v, n.x, i.w, 0, 180),
|
||
|
x = l(v, n.y, i.h, 90, 270);
|
||
|
b.start < d.l && ((d.l = b.start), (c.l = m)),
|
||
|
b.end > d.r && ((d.r = b.end), (c.r = m)),
|
||
|
x.start < d.t && ((d.t = x.start), (c.t = m)),
|
||
|
x.end > d.b && ((d.b = x.end), (c.b = m));
|
||
|
}
|
||
|
t.setReductions(u, d, c);
|
||
|
})(this)
|
||
|
: ((t = this),
|
||
|
(e = Math.min(t.height / 2, t.width / 2)),
|
||
|
(t.drawingArea = Math.round(e)),
|
||
|
t.setCenterPoint(0, 0, 0, 0));
|
||
|
},
|
||
|
setReductions: function (t, e, i) {
|
||
|
var n = e.l / Math.sin(i.l),
|
||
|
a = Math.max(e.r - this.width, 0) / Math.sin(i.r),
|
||
|
o = -e.t / Math.cos(i.t),
|
||
|
r = -Math.max(e.b - this.height, 0) / Math.cos(i.b);
|
||
|
(n = d(n)),
|
||
|
(a = d(a)),
|
||
|
(o = d(o)),
|
||
|
(r = d(r)),
|
||
|
(this.drawingArea = Math.min(
|
||
|
Math.round(t - (n + a) / 2),
|
||
|
Math.round(t - (o + r) / 2)
|
||
|
)),
|
||
|
this.setCenterPoint(n, a, o, r);
|
||
|
},
|
||
|
setCenterPoint: function (t, e, i, n) {
|
||
|
var a = this,
|
||
|
o = a.width - e - a.drawingArea,
|
||
|
r = t + a.drawingArea,
|
||
|
s = i + a.drawingArea,
|
||
|
l = a.height - n - a.drawingArea;
|
||
|
(a.xCenter = Math.round((r + o) / 2 + a.left)),
|
||
|
(a.yCenter = Math.round((s + l) / 2 + a.top));
|
||
|
},
|
||
|
getIndexAngle: function (t) {
|
||
|
return (
|
||
|
t * ((2 * Math.PI) / r(this)) +
|
||
|
((this.chart.options && this.chart.options.startAngle
|
||
|
? this.chart.options.startAngle
|
||
|
: 0) *
|
||
|
Math.PI *
|
||
|
2) /
|
||
|
360
|
||
|
);
|
||
|
},
|
||
|
getDistanceFromCenterForValue: function (t) {
|
||
|
var e = this;
|
||
|
if (null === t) return 0;
|
||
|
var i = e.drawingArea / (e.max - e.min);
|
||
|
return e.options.ticks.reverse
|
||
|
? (e.max - t) * i
|
||
|
: (t - e.min) * i;
|
||
|
},
|
||
|
getPointPosition: function (t, e) {
|
||
|
var i = this.getIndexAngle(t) - Math.PI / 2;
|
||
|
return {
|
||
|
x: Math.round(Math.cos(i) * e) + this.xCenter,
|
||
|
y: Math.round(Math.sin(i) * e) + this.yCenter,
|
||
|
};
|
||
|
},
|
||
|
getPointPositionForValue: function (t, e) {
|
||
|
return this.getPointPosition(
|
||
|
t,
|
||
|
this.getDistanceFromCenterForValue(e)
|
||
|
);
|
||
|
},
|
||
|
getBasePosition: function () {
|
||
|
var t = this.min,
|
||
|
e = this.max;
|
||
|
return this.getPointPositionForValue(
|
||
|
0,
|
||
|
this.beginAtZero
|
||
|
? 0
|
||
|
: t < 0 && e < 0
|
||
|
? e
|
||
|
: t > 0 && e > 0
|
||
|
? t
|
||
|
: 0
|
||
|
);
|
||
|
},
|
||
|
draw: function () {
|
||
|
var t = this,
|
||
|
i = t.options,
|
||
|
n = i.gridLines,
|
||
|
o = i.ticks,
|
||
|
l = a.valueOrDefault;
|
||
|
if (i.display) {
|
||
|
var d = t.ctx,
|
||
|
c = this.getIndexAngle(0),
|
||
|
h = l(o.fontSize, e.defaultFontSize),
|
||
|
f = l(o.fontStyle, e.defaultFontStyle),
|
||
|
g = l(o.fontFamily, e.defaultFontFamily),
|
||
|
p = a.fontString(h, f, g);
|
||
|
a.each(t.ticks, function (i, s) {
|
||
|
if (s > 0 || o.reverse) {
|
||
|
var u = t.getDistanceFromCenterForValue(
|
||
|
t.ticksAsNumbers[s]
|
||
|
);
|
||
|
if (
|
||
|
(n.display &&
|
||
|
0 !== s &&
|
||
|
(function (t, e, i, n) {
|
||
|
var o = t.ctx;
|
||
|
if (
|
||
|
((o.strokeStyle = a.valueAtIndexOrDefault(
|
||
|
e.color,
|
||
|
n - 1
|
||
|
)),
|
||
|
(o.lineWidth = a.valueAtIndexOrDefault(
|
||
|
e.lineWidth,
|
||
|
n - 1
|
||
|
)),
|
||
|
t.options.gridLines.circular)
|
||
|
)
|
||
|
o.beginPath(),
|
||
|
o.arc(t.xCenter, t.yCenter, i, 0, 2 * Math.PI),
|
||
|
o.closePath(),
|
||
|
o.stroke();
|
||
|
else {
|
||
|
var s = r(t);
|
||
|
if (0 === s) return;
|
||
|
o.beginPath();
|
||
|
var l = t.getPointPosition(0, i);
|
||
|
o.moveTo(l.x, l.y);
|
||
|
for (var u = 1; u < s; u++)
|
||
|
(l = t.getPointPosition(u, i)),
|
||
|
o.lineTo(l.x, l.y);
|
||
|
o.closePath(), o.stroke();
|
||
|
}
|
||
|
})(t, n, u, s),
|
||
|
o.display)
|
||
|
) {
|
||
|
var f = l(o.fontColor, e.defaultFontColor);
|
||
|
if (
|
||
|
((d.font = p),
|
||
|
d.save(),
|
||
|
d.translate(t.xCenter, t.yCenter),
|
||
|
d.rotate(c),
|
||
|
o.showLabelBackdrop)
|
||
|
) {
|
||
|
var g = d.measureText(i).width;
|
||
|
(d.fillStyle = o.backdropColor),
|
||
|
d.fillRect(
|
||
|
-g / 2 - o.backdropPaddingX,
|
||
|
-u - h / 2 - o.backdropPaddingY,
|
||
|
g + 2 * o.backdropPaddingX,
|
||
|
h + 2 * o.backdropPaddingY
|
||
|
);
|
||
|
}
|
||
|
(d.textAlign = "center"),
|
||
|
(d.textBaseline = "middle"),
|
||
|
(d.fillStyle = f),
|
||
|
d.fillText(i, 0, -u),
|
||
|
d.restore();
|
||
|
}
|
||
|
}
|
||
|
}),
|
||
|
(i.angleLines.display || i.pointLabels.display) &&
|
||
|
(function (t) {
|
||
|
var i = t.ctx,
|
||
|
n = t.options,
|
||
|
o = n.angleLines,
|
||
|
l = n.pointLabels;
|
||
|
(i.lineWidth = o.lineWidth), (i.strokeStyle = o.color);
|
||
|
var d,
|
||
|
c,
|
||
|
h,
|
||
|
f,
|
||
|
g = t.getDistanceFromCenterForValue(
|
||
|
n.ticks.reverse ? t.min : t.max
|
||
|
),
|
||
|
p = s(t);
|
||
|
i.textBaseline = "top";
|
||
|
for (var m = r(t) - 1; m >= 0; m--) {
|
||
|
if (o.display) {
|
||
|
var v = t.getPointPosition(m, g);
|
||
|
i.beginPath(),
|
||
|
i.moveTo(t.xCenter, t.yCenter),
|
||
|
i.lineTo(v.x, v.y),
|
||
|
i.stroke(),
|
||
|
i.closePath();
|
||
|
}
|
||
|
if (l.display) {
|
||
|
var b = t.getPointPosition(m, g + 5),
|
||
|
x = a.valueAtIndexOrDefault(
|
||
|
l.fontColor,
|
||
|
m,
|
||
|
e.defaultFontColor
|
||
|
);
|
||
|
(i.font = p.font), (i.fillStyle = x);
|
||
|
var y = t.getIndexAngle(m),
|
||
|
k = a.toDegrees(y);
|
||
|
(i.textAlign =
|
||
|
0 === (f = k) || 180 === f
|
||
|
? "center"
|
||
|
: f < 180
|
||
|
? "left"
|
||
|
: "right"),
|
||
|
(d = k),
|
||
|
(c = t._pointLabelSizes[m]),
|
||
|
(h = b),
|
||
|
90 === d || 270 === d
|
||
|
? (h.y -= c.h / 2)
|
||
|
: (d > 270 || d < 90) && (h.y -= c.h),
|
||
|
u(i, t.pointLabels[m] || "", b, p.size);
|
||
|
}
|
||
|
}
|
||
|
})(t);
|
||
|
}
|
||
|
},
|
||
|
});
|
||
|
t.scaleService.registerScaleType("radialLinear", c, i);
|
||
|
};
|
||
|
},
|
||
|
{ 25: 25, 34: 34, 45: 45 },
|
||
|
],
|
||
|
58: [
|
||
|
function (t, e, i) {
|
||
|
"use strict";
|
||
|
var n = t(1);
|
||
|
n = "function" == typeof n ? n : window.moment;
|
||
|
var a = t(25),
|
||
|
o = t(45),
|
||
|
r = Number.MIN_SAFE_INTEGER || -9007199254740991,
|
||
|
s = Number.MAX_SAFE_INTEGER || 9007199254740991,
|
||
|
l = {
|
||
|
millisecond: {
|
||
|
common: !0,
|
||
|
size: 1,
|
||
|
steps: [1, 2, 5, 10, 20, 50, 100, 250, 500],
|
||
|
},
|
||
|
second: { common: !0, size: 1e3, steps: [1, 2, 5, 10, 30] },
|
||
|
minute: { common: !0, size: 6e4, steps: [1, 2, 5, 10, 30] },
|
||
|
hour: { common: !0, size: 36e5, steps: [1, 2, 3, 6, 12] },
|
||
|
day: { common: !0, size: 864e5, steps: [1, 2, 5] },
|
||
|
week: { common: !1, size: 6048e5, steps: [1, 2, 3, 4] },
|
||
|
month: { common: !0, size: 2628e6, steps: [1, 2, 3] },
|
||
|
quarter: { common: !1, size: 7884e6, steps: [1, 2, 3, 4] },
|
||
|
year: { common: !0, size: 3154e7 },
|
||
|
},
|
||
|
u = Object.keys(l);
|
||
|
function d(t, e) {
|
||
|
return t - e;
|
||
|
}
|
||
|
function c(t) {
|
||
|
var e,
|
||
|
i,
|
||
|
n,
|
||
|
a = {},
|
||
|
o = [];
|
||
|
for (e = 0, i = t.length; e < i; ++e)
|
||
|
a[(n = t[e])] || ((a[n] = !0), o.push(n));
|
||
|
return o;
|
||
|
}
|
||
|
function h(t, e, i, n) {
|
||
|
var a = (function (t, e, i) {
|
||
|
for (var n, a, o, r = 0, s = t.length - 1; r >= 0 && r <= s; ) {
|
||
|
if (((a = t[(n = (r + s) >> 1) - 1] || null), (o = t[n]), !a))
|
||
|
return { lo: null, hi: o };
|
||
|
if (o[e] < i) r = n + 1;
|
||
|
else {
|
||
|
if (!(a[e] > i)) return { lo: a, hi: o };
|
||
|
s = n - 1;
|
||
|
}
|
||
|
}
|
||
|
return { lo: o, hi: null };
|
||
|
})(t, e, i),
|
||
|
o = a.lo ? (a.hi ? a.lo : t[t.length - 2]) : t[0],
|
||
|
r = a.lo ? (a.hi ? a.hi : t[t.length - 1]) : t[1],
|
||
|
s = r[e] - o[e],
|
||
|
l = s ? (i - o[e]) / s : 0,
|
||
|
u = (r[n] - o[n]) * l;
|
||
|
return o[n] + u;
|
||
|
}
|
||
|
function f(t, e) {
|
||
|
var i = e.parser,
|
||
|
a = e.parser || e.format;
|
||
|
return "function" == typeof i
|
||
|
? i(t)
|
||
|
: "string" == typeof t && "string" == typeof a
|
||
|
? n(t, a)
|
||
|
: (t instanceof n || (t = n(t)),
|
||
|
t.isValid() ? t : "function" == typeof a ? a(t) : t);
|
||
|
}
|
||
|
function g(t, e) {
|
||
|
if (o.isNullOrUndef(t)) return null;
|
||
|
var i = e.options.time,
|
||
|
n = f(e.getRightValue(t), i);
|
||
|
return n.isValid()
|
||
|
? (i.round && n.startOf(i.round), n.valueOf())
|
||
|
: null;
|
||
|
}
|
||
|
function p(t) {
|
||
|
for (var e = u.indexOf(t) + 1, i = u.length; e < i; ++e)
|
||
|
if (l[u[e]].common) return u[e];
|
||
|
}
|
||
|
function m(t, e, i, a) {
|
||
|
var r,
|
||
|
d = a.time,
|
||
|
c =
|
||
|
d.unit ||
|
||
|
(function (t, e, i, n) {
|
||
|
var a,
|
||
|
o,
|
||
|
r,
|
||
|
d = u.length;
|
||
|
for (a = u.indexOf(t); a < d - 1; ++a)
|
||
|
if (
|
||
|
((r = (o = l[u[a]]).steps
|
||
|
? o.steps[o.steps.length - 1]
|
||
|
: s),
|
||
|
o.common && Math.ceil((i - e) / (r * o.size)) <= n)
|
||
|
)
|
||
|
return u[a];
|
||
|
return u[d - 1];
|
||
|
})(d.minUnit, t, e, i),
|
||
|
h = p(c),
|
||
|
f = o.valueOrDefault(d.stepSize, d.unitStepSize),
|
||
|
g = "week" === c && d.isoWeekday,
|
||
|
m = a.ticks.major.enabled,
|
||
|
v = l[c],
|
||
|
b = n(t),
|
||
|
x = n(e),
|
||
|
y = [];
|
||
|
for (
|
||
|
f ||
|
||
|
(f = (function (t, e, i, n) {
|
||
|
var a,
|
||
|
o,
|
||
|
r,
|
||
|
s = e - t,
|
||
|
u = l[i],
|
||
|
d = u.size,
|
||
|
c = u.steps;
|
||
|
if (!c) return Math.ceil(s / (n * d));
|
||
|
for (
|
||
|
a = 0, o = c.length;
|
||
|
a < o && ((r = c[a]), !(Math.ceil(s / (d * r)) <= n));
|
||
|
++a
|
||
|
);
|
||
|
return r;
|
||
|
})(t, e, c, i)),
|
||
|
g && ((b = b.isoWeekday(g)), (x = x.isoWeekday(g))),
|
||
|
b = b.startOf(g ? "day" : c),
|
||
|
(x = x.startOf(g ? "day" : c)) < e && x.add(1, c),
|
||
|
r = n(b),
|
||
|
m &&
|
||
|
h &&
|
||
|
!g &&
|
||
|
!d.round &&
|
||
|
(r.startOf(h), r.add(~~((b - r) / (v.size * f)) * f, c));
|
||
|
r < x;
|
||
|
r.add(f, c)
|
||
|
)
|
||
|
y.push(+r);
|
||
|
return y.push(+r), y;
|
||
|
}
|
||
|
e.exports = function (t) {
|
||
|
var e = t.Scale.extend({
|
||
|
initialize: function () {
|
||
|
if (!n)
|
||
|
throw new Error(
|
||
|
"Chart.js - Moment.js could not be found! You must include it before Chart.js to use the time scale. Download at https://momentjs.com"
|
||
|
);
|
||
|
this.mergeTicksOptions(),
|
||
|
t.Scale.prototype.initialize.call(this);
|
||
|
},
|
||
|
update: function () {
|
||
|
var e = this.options;
|
||
|
return (
|
||
|
e.time &&
|
||
|
e.time.format &&
|
||
|
console.warn(
|
||
|
"options.time.format is deprecated and replaced by options.time.parser."
|
||
|
),
|
||
|
t.Scale.prototype.update.apply(this, arguments)
|
||
|
);
|
||
|
},
|
||
|
getRightValue: function (e) {
|
||
|
return (
|
||
|
e && void 0 !== e.t && (e = e.t),
|
||
|
t.Scale.prototype.getRightValue.call(this, e)
|
||
|
);
|
||
|
},
|
||
|
determineDataLimits: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i,
|
||
|
a,
|
||
|
l,
|
||
|
u,
|
||
|
h = this,
|
||
|
f = h.chart,
|
||
|
p = h.options.time,
|
||
|
m = p.unit || "day",
|
||
|
v = s,
|
||
|
b = r,
|
||
|
x = [],
|
||
|
y = [],
|
||
|
k = [];
|
||
|
for (t = 0, i = f.data.labels.length; t < i; ++t)
|
||
|
k.push(g(f.data.labels[t], h));
|
||
|
for (t = 0, i = (f.data.datasets || []).length; t < i; ++t)
|
||
|
if (f.isDatasetVisible(t))
|
||
|
if (((l = f.data.datasets[t].data), o.isObject(l[0])))
|
||
|
for (y[t] = [], e = 0, a = l.length; e < a; ++e)
|
||
|
(u = g(l[e], h)), x.push(u), (y[t][e] = u);
|
||
|
else x.push.apply(x, k), (y[t] = k.slice(0));
|
||
|
else y[t] = [];
|
||
|
k.length &&
|
||
|
((k = c(k).sort(d)),
|
||
|
(v = Math.min(v, k[0])),
|
||
|
(b = Math.max(b, k[k.length - 1]))),
|
||
|
x.length &&
|
||
|
((x = c(x).sort(d)),
|
||
|
(v = Math.min(v, x[0])),
|
||
|
(b = Math.max(b, x[x.length - 1]))),
|
||
|
(v = g(p.min, h) || v),
|
||
|
(b = g(p.max, h) || b),
|
||
|
(v = v === s ? +n().startOf(m) : v),
|
||
|
(b = b === r ? +n().endOf(m) + 1 : b),
|
||
|
(h.min = Math.min(v, b)),
|
||
|
(h.max = Math.max(v + 1, b)),
|
||
|
(h._horizontal = h.isHorizontal()),
|
||
|
(h._table = []),
|
||
|
(h._timestamps = { data: x, datasets: y, labels: k });
|
||
|
},
|
||
|
buildTicks: function () {
|
||
|
var t,
|
||
|
e,
|
||
|
i,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s,
|
||
|
d,
|
||
|
c,
|
||
|
v,
|
||
|
b,
|
||
|
x,
|
||
|
y = this,
|
||
|
k = y.min,
|
||
|
M = y.max,
|
||
|
w = y.options,
|
||
|
S = w.time,
|
||
|
C = [],
|
||
|
_ = [];
|
||
|
switch (w.ticks.source) {
|
||
|
case "data":
|
||
|
C = y._timestamps.data;
|
||
|
break;
|
||
|
case "labels":
|
||
|
C = y._timestamps.labels;
|
||
|
break;
|
||
|
case "auto":
|
||
|
default:
|
||
|
C = m(k, M, y.getLabelCapacity(k), w);
|
||
|
}
|
||
|
for (
|
||
|
"ticks" === w.bounds &&
|
||
|
C.length &&
|
||
|
((k = C[0]), (M = C[C.length - 1])),
|
||
|
k = g(S.min, y) || k,
|
||
|
M = g(S.max, y) || M,
|
||
|
t = 0,
|
||
|
e = C.length;
|
||
|
t < e;
|
||
|
++t
|
||
|
)
|
||
|
(i = C[t]) >= k && i <= M && _.push(i);
|
||
|
return (
|
||
|
(y.min = k),
|
||
|
(y.max = M),
|
||
|
(y._unit =
|
||
|
S.unit ||
|
||
|
(function (t, e, i, a) {
|
||
|
var o,
|
||
|
r,
|
||
|
s = n.duration(n(a).diff(n(i)));
|
||
|
for (o = u.length - 1; o >= u.indexOf(e); o--)
|
||
|
if (((r = u[o]), l[r].common && s.as(r) >= t.length))
|
||
|
return r;
|
||
|
return u[e ? u.indexOf(e) : 0];
|
||
|
})(_, S.minUnit, y.min, y.max)),
|
||
|
(y._majorUnit = p(y._unit)),
|
||
|
(y._table = (function (t, e, i, n) {
|
||
|
if ("linear" === n || !t.length)
|
||
|
return [
|
||
|
{ time: e, pos: 0 },
|
||
|
{ time: i, pos: 1 },
|
||
|
];
|
||
|
var a,
|
||
|
o,
|
||
|
r,
|
||
|
s,
|
||
|
l,
|
||
|
u = [],
|
||
|
d = [e];
|
||
|
for (a = 0, o = t.length; a < o; ++a)
|
||
|
(s = t[a]) > e && s < i && d.push(s);
|
||
|
for (d.push(i), a = 0, o = d.length; a < o; ++a)
|
||
|
(l = d[a + 1]),
|
||
|
(r = d[a - 1]),
|
||
|
(s = d[a]),
|
||
|
(void 0 !== r &&
|
||
|
void 0 !== l &&
|
||
|
Math.round((l + r) / 2) === s) ||
|
||
|
u.push({ time: s, pos: a / (o - 1) });
|
||
|
return u;
|
||
|
})(y._timestamps.data, k, M, w.distribution)),
|
||
|
(y._offsets =
|
||
|
((a = y._table),
|
||
|
(o = _),
|
||
|
(r = k),
|
||
|
(s = M),
|
||
|
(b = 0),
|
||
|
(x = 0),
|
||
|
(d = w).offset &&
|
||
|
o.length &&
|
||
|
(d.time.min ||
|
||
|
((c = o.length > 1 ? o[1] : s),
|
||
|
(v = o[0]),
|
||
|
(b =
|
||
|
(h(a, "time", c, "pos") - h(a, "time", v, "pos")) /
|
||
|
2)),
|
||
|
d.time.max ||
|
||
|
((c = o[o.length - 1]),
|
||
|
(v = o.length > 1 ? o[o.length - 2] : r),
|
||
|
(x =
|
||
|
(h(a, "time", c, "pos") - h(a, "time", v, "pos")) /
|
||
|
2))),
|
||
|
{ left: b, right: x })),
|
||
|
(y._labelFormat = (function (t, e) {
|
||
|
var i,
|
||
|
n,
|
||
|
a,
|
||
|
o = t.length;
|
||
|
for (i = 0; i < o; i++) {
|
||
|
if (0 !== (n = f(t[i], e)).millisecond())
|
||
|
return "MMM D, YYYY h:mm:ss.SSS a";
|
||
|
(0 === n.second() &&
|
||
|
0 === n.minute() &&
|
||
|
0 === n.hour()) ||
|
||
|
(a = !0);
|
||
|
}
|
||
|
return a ? "MMM D, YYYY h:mm:ss a" : "MMM D, YYYY";
|
||
|
})(y._timestamps.data, S)),
|
||
|
(function (t, e) {
|
||
|
var i,
|
||
|
a,
|
||
|
o,
|
||
|
r,
|
||
|
s = [];
|
||
|
for (i = 0, a = t.length; i < a; ++i)
|
||
|
(o = t[i]),
|
||
|
(r = !!e && o === +n(o).startOf(e)),
|
||
|
s.push({ value: o, major: r });
|
||
|
return s;
|
||
|
})(_, y._majorUnit)
|
||
|
);
|
||
|
},
|
||
|
getLabelForIndex: function (t, e) {
|
||
|
var i = this.chart.data,
|
||
|
n = this.options.time,
|
||
|
a = i.labels && t < i.labels.length ? i.labels[t] : "",
|
||
|
r = i.datasets[e].data[t];
|
||
|
return (
|
||
|
o.isObject(r) && (a = this.getRightValue(r)),
|
||
|
n.tooltipFormat
|
||
|
? f(a, n).format(n.tooltipFormat)
|
||
|
: "string" == typeof a
|
||
|
? a
|
||
|
: f(a, n).format(this._labelFormat)
|
||
|
);
|
||
|
},
|
||
|
tickFormatFunction: function (t, e, i, n) {
|
||
|
var a = this.options,
|
||
|
r = t.valueOf(),
|
||
|
s = a.time.displayFormats,
|
||
|
l = s[this._unit],
|
||
|
u = this._majorUnit,
|
||
|
d = s[u],
|
||
|
c = t.clone().startOf(u).valueOf(),
|
||
|
h = a.ticks.major,
|
||
|
f = h.enabled && u && d && r === c,
|
||
|
g = t.format(n || (f ? d : l)),
|
||
|
p = f ? h : a.ticks.minor,
|
||
|
m = o.valueOrDefault(p.callback, p.userCallback);
|
||
|
return m ? m(g, e, i) : g;
|
||
|
},
|
||
|
convertTicksToLabels: function (t) {
|
||
|
var e,
|
||
|
i,
|
||
|
a = [];
|
||
|
for (e = 0, i = t.length; e < i; ++e)
|
||
|
a.push(this.tickFormatFunction(n(t[e].value), e, t));
|
||
|
return a;
|
||
|
},
|
||
|
getPixelForOffset: function (t) {
|
||
|
var e = this,
|
||
|
i = e._horizontal ? e.width : e.height,
|
||
|
n = e._horizontal ? e.left : e.top,
|
||
|
a = h(e._table, "time", t, "pos");
|
||
|
return (
|
||
|
n +
|
||
|
(i * (e._offsets.left + a)) /
|
||
|
(e._offsets.left + 1 + e._offsets.right)
|
||
|
);
|
||
|
},
|
||
|
getPixelForValue: function (t, e, i) {
|
||
|
var n = null;
|
||
|
if (
|
||
|
(void 0 !== e &&
|
||
|
void 0 !== i &&
|
||
|
(n = this._timestamps.datasets[i][e]),
|
||
|
null === n && (n = g(t, this)),
|
||
|
null !== n)
|
||
|
)
|
||
|
return this.getPixelForOffset(n);
|
||
|
},
|
||
|
getPixelForTick: function (t) {
|
||
|
var e = this.getTicks();
|
||
|
return t >= 0 && t < e.length
|
||
|
? this.getPixelForOffset(e[t].value)
|
||
|
: null;
|
||
|
},
|
||
|
getValueForPixel: function (t) {
|
||
|
var e = this,
|
||
|
i = e._horizontal ? e.width : e.height,
|
||
|
a = e._horizontal ? e.left : e.top,
|
||
|
o =
|
||
|
(i ? (t - a) / i : 0) *
|
||
|
(e._offsets.left + 1 + e._offsets.left) -
|
||
|
e._offsets.right,
|
||
|
r = h(e._table, "pos", o, "time");
|
||
|
return n(r);
|
||
|
},
|
||
|
getLabelWidth: function (t) {
|
||
|
var e = this.options.ticks,
|
||
|
i = this.ctx.measureText(t).width,
|
||
|
n = o.toRadians(e.maxRotation),
|
||
|
r = Math.cos(n),
|
||
|
s = Math.sin(n);
|
||
|
return (
|
||
|
i * r +
|
||
|
o.valueOrDefault(e.fontSize, a.global.defaultFontSize) * s
|
||
|
);
|
||
|
},
|
||
|
getLabelCapacity: function (t) {
|
||
|
var e = this,
|
||
|
i = e.options.time.displayFormats.millisecond,
|
||
|
a = e.tickFormatFunction(n(t), 0, [], i),
|
||
|
o = e.getLabelWidth(a),
|
||
|
r = e.isHorizontal() ? e.width : e.height,
|
||
|
s = Math.floor(r / o);
|
||
|
return s > 0 ? s : 1;
|
||
|
},
|
||
|
});
|
||
|
t.scaleService.registerScaleType("time", e, {
|
||
|
position: "bottom",
|
||
|
distribution: "linear",
|
||
|
bounds: "data",
|
||
|
time: {
|
||
|
parser: !1,
|
||
|
format: !1,
|
||
|
unit: !1,
|
||
|
round: !1,
|
||
|
displayFormat: !1,
|
||
|
isoWeekday: !1,
|
||
|
minUnit: "millisecond",
|
||
|
displayFormats: {
|
||
|
millisecond: "h:mm:ss.SSS a",
|
||
|
second: "h:mm:ss a",
|
||
|
minute: "h:mm a",
|
||
|
hour: "hA",
|
||
|
day: "MMM D",
|
||
|
week: "ll",
|
||
|
month: "MMM YYYY",
|
||
|
quarter: "[Q]Q - YYYY",
|
||
|
year: "YYYY",
|
||
|
},
|
||
|
},
|
||
|
ticks: { autoSkip: !1, source: "auto", major: { enabled: !1 } },
|
||
|
});
|
||
|
};
|
||
|
},
|
||
|
{ 1: 1, 25: 25, 45: 45 },
|
||
|
],
|
||
|
},
|
||
|
{},
|
||
|
[7]
|
||
|
)(7);
|
||
|
});
|