From 14691c6eef7f7de0d9758b37a7d9bc68457e0143 Mon Sep 17 00:00:00 2001 From: GitHub Actions <> Date: Sat, 26 Oct 2024 19:00:54 +0000 Subject: [PATCH] gh pages --- index.450a67f6.js.map | 1 - index.450a67f6.js => index.92b3d5d1.js | 4 ++-- index.92b3d5d1.js.map | 1 + index.html | 2 +- ogimage.png | Bin 14629 -> 14622 bytes 5 files changed, 4 insertions(+), 4 deletions(-) delete mode 100644 index.450a67f6.js.map rename index.450a67f6.js => index.92b3d5d1.js (96%) create mode 100644 index.92b3d5d1.js.map diff --git a/index.450a67f6.js.map b/index.450a67f6.js.map deleted file mode 100644 index 69bd27db..00000000 --- a/index.450a67f6.js.map +++ /dev/null @@ -1 +0,0 @@ -{"mappings":"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","sources":["data.json","node_modules/chart.js/dist/chunks/helpers.segment.js","node_modules/chart.js/dist/chart.esm.js","node_modules/chart.js/auto/auto.esm.js","node_modules/chartjs-plugin-annotation/dist/chartjs-plugin-annotation.esm.js","index.js"],"sourcesContent":["{\n \"lock\": {\n \"labels\": [],\n \"datasets\": [\n {\n \"data\": [\n {\n \"id\": \"pdm 2.19.3\",\n \"max\": \"72.59\",\n \"min\": \"70.1\",\n \"avg\": \"71.74\"\n },\n {\n \"id\": \"pip-tools 7.4.1\",\n \"max\": \"31.17\",\n \"min\": \"28.22\",\n \"avg\": \"29.87\"\n },\n {\n \"id\": \"pipenv 2024.2.0\",\n \"max\": \"46.71\",\n \"min\": \"43.69\",\n \"avg\": \"45.83\"\n },\n {\n \"id\": \"poetry 1.8.4\",\n \"max\": \"18.56\",\n \"min\": \"15.51\",\n \"avg\": \"17.2\"\n },\n {\n \"id\": \"uv 0.4.27\",\n \"max\": \"2.15\",\n \"min\": \"1.78\",\n \"avg\": \"2.03\"\n }\n ],\n \"label\": \"cold\"\n },\n {\n \"data\": [\n {\n \"id\": \"pdm 2.19.3\",\n \"max\": \"66.39\",\n \"min\": \"64.62\",\n \"avg\": \"65.13\"\n },\n {\n \"id\": \"pip-tools 7.4.1\",\n \"max\": \"24.61\",\n \"min\": \"22.4\",\n \"avg\": \"23.43\"\n },\n {\n \"id\": \"pipenv 2024.2.0\",\n \"max\": \"41.41\",\n \"min\": \"38.78\",\n \"avg\": \"39.97\"\n },\n {\n \"id\": \"poetry 1.8.4\",\n \"max\": \"8.02\",\n \"min\": \"7.33\",\n \"avg\": \"7.64\"\n },\n {\n \"id\": \"uv 0.4.27\",\n \"max\": \"0.12\",\n \"min\": \"0.11\",\n \"avg\": \"0.11\"\n }\n ],\n \"label\": \"warm\"\n }\n ]\n },\n \"install\": {\n \"labels\": [],\n \"datasets\": [\n {\n \"data\": [\n {\n \"id\": \"pdm 2.19.3\",\n \"max\": \"43.72\",\n \"min\": \"39.6\",\n \"avg\": \"41.27\"\n },\n {\n \"id\": \"pip-tools 7.4.1\",\n \"max\": \"53.85\",\n \"min\": \"45.82\",\n \"avg\": \"48.95\"\n },\n {\n \"id\": \"pipenv 2024.2.0\",\n \"max\": \"42.68\",\n \"min\": \"41.52\",\n \"avg\": \"42.29\"\n },\n {\n \"id\": \"poetry 1.8.4\",\n \"max\": \"27.39\",\n \"min\": \"25.9\",\n \"avg\": \"26.6\"\n },\n {\n \"id\": \"uv 0.4.27\",\n \"max\": \"20.88\",\n \"min\": \"18.69\",\n \"avg\": \"19.55\"\n }\n ],\n \"label\": \"cold\"\n },\n {\n \"data\": [\n {\n \"id\": \"pdm 2.19.3\",\n \"max\": \"26.0\",\n \"min\": \"25.47\",\n \"avg\": \"25.82\"\n },\n {\n \"id\": \"pip-tools 7.4.1\",\n \"max\": \"27.64\",\n \"min\": \"26.44\",\n \"avg\": \"27.17\"\n },\n {\n \"id\": \"pipenv 2024.2.0\",\n \"max\": \"22.05\",\n \"min\": \"21.01\",\n \"avg\": \"21.56\"\n },\n {\n \"id\": \"poetry 1.8.4\",\n \"max\": \"6.2\",\n \"min\": \"5.96\",\n \"avg\": \"6.04\"\n },\n {\n \"id\": \"uv 0.4.27\",\n \"max\": \"0.3\",\n \"min\": \"0.26\",\n \"avg\": \"0.28\"\n }\n ],\n \"label\": \"warm\"\n }\n ]\n },\n \"update\": {\n \"labels\": [],\n \"datasets\": [\n {\n \"data\": [\n {\n \"id\": \"pdm 2.19.3\",\n \"max\": \"63.33\",\n \"min\": \"61.72\",\n \"avg\": \"62.51\"\n },\n {\n \"id\": \"pip-tools 7.4.1\",\n \"max\": \"16.4\",\n \"min\": \"13.98\",\n \"avg\": \"15.19\"\n },\n {\n \"id\": \"pipenv 2024.2.0\",\n \"max\": \"71.88\",\n \"min\": \"67.69\",\n \"avg\": \"70.46\"\n },\n {\n \"id\": \"poetry 1.8.4\",\n \"max\": \"18.8\",\n \"min\": \"15.67\",\n \"avg\": \"17.42\"\n },\n {\n \"id\": \"uv 0.4.27\",\n \"max\": \"1.73\",\n \"min\": \"1.67\",\n \"avg\": \"1.7\"\n }\n ],\n \"label\": \"cold\"\n },\n {\n \"data\": [\n {\n \"id\": \"pdm 2.19.3\",\n \"max\": \"57.44\",\n \"min\": \"56.56\",\n \"avg\": \"56.89\"\n },\n {\n \"id\": \"pip-tools 7.4.1\",\n \"max\": \"13.12\",\n \"min\": \"12.14\",\n \"avg\": \"12.86\"\n },\n {\n \"id\": \"pipenv 2024.2.0\",\n \"max\": \"66.53\",\n \"min\": \"62.32\",\n \"avg\": \"64.52\"\n },\n {\n \"id\": \"poetry 1.8.4\",\n \"max\": \"8.67\",\n \"min\": \"7.89\",\n \"avg\": \"8.25\"\n },\n {\n \"id\": \"uv 0.4.27\",\n \"max\": \"0.29\",\n \"min\": \"0.26\",\n \"avg\": \"0.28\"\n }\n ],\n \"label\": \"warm\"\n }\n ]\n },\n \"add-package\": {\n \"labels\": [],\n \"datasets\": [\n {\n \"data\": [\n {\n \"id\": \"pdm 2.19.3\",\n \"max\": \"33.56\",\n \"min\": \"32.01\",\n \"avg\": \"32.6\"\n },\n {\n \"id\": \"pip-tools 7.4.1\",\n \"max\": \"14.72\",\n \"min\": \"13.17\",\n \"avg\": \"13.97\"\n },\n {\n \"id\": \"pipenv 2024.2.0\",\n \"max\": \"75.53\",\n \"min\": \"72.25\",\n \"avg\": \"73.54\"\n },\n {\n \"id\": \"poetry 1.8.4\",\n \"max\": \"3.63\",\n \"min\": \"3.14\",\n \"avg\": \"3.36\"\n },\n {\n \"id\": \"uv 0.4.27\",\n \"max\": \"0.35\",\n \"min\": \"0.22\",\n \"avg\": \"0.3\"\n }\n ]\n }\n ]\n },\n \"tooling\": {\n \"labels\": [],\n \"datasets\": [\n {\n \"data\": [\n {\n \"id\": \"pdm 2.19.3\",\n \"max\": \"15.36\",\n \"min\": \"11.71\",\n \"avg\": \"12.74\"\n },\n {\n \"id\": \"pip-tools 7.4.1\",\n \"max\": \"1.59\",\n \"min\": \"0.99\",\n \"avg\": \"1.27\"\n },\n {\n \"id\": \"pipenv 2024.2.0\",\n \"max\": \"4.38\",\n \"min\": \"3.43\",\n \"avg\": \"3.76\"\n },\n {\n \"id\": \"poetry 1.8.4\",\n \"max\": \"7.82\",\n \"min\": \"6.07\",\n \"avg\": \"6.96\"\n },\n {\n \"id\": \"uv 0.4.27\",\n \"max\": \"1.18\",\n \"min\": \"1.06\",\n \"avg\": \"1.13\"\n }\n ]\n }\n ]\n }\n}\n","/*!\n * Chart.js v3.8.0\n * https://www.chartjs.org\n * (c) 2022 Chart.js Contributors\n * Released under the MIT License\n */\nfunction fontString(pixelSize, fontStyle, fontFamily) {\n return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;\n}\nconst requestAnimFrame = (function() {\n if (typeof window === 'undefined') {\n return function(callback) {\n return callback();\n };\n }\n return window.requestAnimationFrame;\n}());\nfunction throttled(fn, thisArg, updateFn) {\n const updateArgs = updateFn || ((args) => Array.prototype.slice.call(args));\n let ticking = false;\n let args = [];\n return function(...rest) {\n args = updateArgs(rest);\n if (!ticking) {\n ticking = true;\n requestAnimFrame.call(window, () => {\n ticking = false;\n fn.apply(thisArg, args);\n });\n }\n };\n}\nfunction debounce(fn, delay) {\n let timeout;\n return function(...args) {\n if (delay) {\n clearTimeout(timeout);\n timeout = setTimeout(fn, delay, args);\n } else {\n fn.apply(this, args);\n }\n return delay;\n };\n}\nconst _toLeftRightCenter = (align) => align === 'start' ? 'left' : align === 'end' ? 'right' : 'center';\nconst _alignStartEnd = (align, start, end) => align === 'start' ? start : align === 'end' ? end : (start + end) / 2;\nconst _textX = (align, left, right, rtl) => {\n const check = rtl ? 'left' : 'right';\n return align === check ? right : align === 'center' ? (left + right) / 2 : left;\n};\n\nfunction noop() {}\nconst uid = (function() {\n let id = 0;\n return function() {\n return id++;\n };\n}());\nfunction isNullOrUndef(value) {\n return value === null || typeof value === 'undefined';\n}\nfunction isArray(value) {\n if (Array.isArray && Array.isArray(value)) {\n return true;\n }\n const type = Object.prototype.toString.call(value);\n if (type.slice(0, 7) === '[object' && type.slice(-6) === 'Array]') {\n return true;\n }\n return false;\n}\nfunction isObject(value) {\n return value !== null && Object.prototype.toString.call(value) === '[object Object]';\n}\nconst isNumberFinite = (value) => (typeof value === 'number' || value instanceof Number) && isFinite(+value);\nfunction finiteOrDefault(value, defaultValue) {\n return isNumberFinite(value) ? value : defaultValue;\n}\nfunction valueOrDefault(value, defaultValue) {\n return typeof value === 'undefined' ? defaultValue : value;\n}\nconst toPercentage = (value, dimension) =>\n typeof value === 'string' && value.endsWith('%') ?\n parseFloat(value) / 100\n : value / dimension;\nconst toDimension = (value, dimension) =>\n typeof value === 'string' && value.endsWith('%') ?\n parseFloat(value) / 100 * dimension\n : +value;\nfunction callback(fn, args, thisArg) {\n if (fn && typeof fn.call === 'function') {\n return fn.apply(thisArg, args);\n }\n}\nfunction each(loopable, fn, thisArg, reverse) {\n let i, len, keys;\n if (isArray(loopable)) {\n len = loopable.length;\n if (reverse) {\n for (i = len - 1; i >= 0; i--) {\n fn.call(thisArg, loopable[i], i);\n }\n } else {\n for (i = 0; i < len; i++) {\n fn.call(thisArg, loopable[i], i);\n }\n }\n } else if (isObject(loopable)) {\n keys = Object.keys(loopable);\n len = keys.length;\n for (i = 0; i < len; i++) {\n fn.call(thisArg, loopable[keys[i]], keys[i]);\n }\n }\n}\nfunction _elementsEqual(a0, a1) {\n let i, ilen, v0, v1;\n if (!a0 || !a1 || a0.length !== a1.length) {\n return false;\n }\n for (i = 0, ilen = a0.length; i < ilen; ++i) {\n v0 = a0[i];\n v1 = a1[i];\n if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {\n return false;\n }\n }\n return true;\n}\nfunction clone$1(source) {\n if (isArray(source)) {\n return source.map(clone$1);\n }\n if (isObject(source)) {\n const target = Object.create(null);\n const keys = Object.keys(source);\n const klen = keys.length;\n let k = 0;\n for (; k < klen; ++k) {\n target[keys[k]] = clone$1(source[keys[k]]);\n }\n return target;\n }\n return source;\n}\nfunction isValidKey(key) {\n return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1;\n}\nfunction _merger(key, target, source, options) {\n if (!isValidKey(key)) {\n return;\n }\n const tval = target[key];\n const sval = source[key];\n if (isObject(tval) && isObject(sval)) {\n merge(tval, sval, options);\n } else {\n target[key] = clone$1(sval);\n }\n}\nfunction merge(target, source, options) {\n const sources = isArray(source) ? source : [source];\n const ilen = sources.length;\n if (!isObject(target)) {\n return target;\n }\n options = options || {};\n const merger = options.merger || _merger;\n for (let i = 0; i < ilen; ++i) {\n source = sources[i];\n if (!isObject(source)) {\n continue;\n }\n const keys = Object.keys(source);\n for (let k = 0, klen = keys.length; k < klen; ++k) {\n merger(keys[k], target, source, options);\n }\n }\n return target;\n}\nfunction mergeIf(target, source) {\n return merge(target, source, {merger: _mergerIf});\n}\nfunction _mergerIf(key, target, source) {\n if (!isValidKey(key)) {\n return;\n }\n const tval = target[key];\n const sval = source[key];\n if (isObject(tval) && isObject(sval)) {\n mergeIf(tval, sval);\n } else if (!Object.prototype.hasOwnProperty.call(target, key)) {\n target[key] = clone$1(sval);\n }\n}\nfunction _deprecated(scope, value, previous, current) {\n if (value !== undefined) {\n console.warn(scope + ': \"' + previous +\n\t\t\t'\" is deprecated. Please use \"' + current + '\" instead');\n }\n}\nconst emptyString = '';\nconst dot = '.';\nfunction indexOfDotOrLength(key, start) {\n const idx = key.indexOf(dot, start);\n return idx === -1 ? key.length : idx;\n}\nfunction resolveObjectKey(obj, key) {\n if (key === emptyString) {\n return obj;\n }\n let pos = 0;\n let idx = indexOfDotOrLength(key, pos);\n while (obj && idx > pos) {\n obj = obj[key.slice(pos, idx)];\n pos = idx + 1;\n idx = indexOfDotOrLength(key, pos);\n }\n return obj;\n}\nfunction _capitalize(str) {\n return str.charAt(0).toUpperCase() + str.slice(1);\n}\nconst defined = (value) => typeof value !== 'undefined';\nconst isFunction = (value) => typeof value === 'function';\nconst setsEqual = (a, b) => {\n if (a.size !== b.size) {\n return false;\n }\n for (const item of a) {\n if (!b.has(item)) {\n return false;\n }\n }\n return true;\n};\nfunction _isClickEvent(e) {\n return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu';\n}\n\nconst PI = Math.PI;\nconst TAU = 2 * PI;\nconst PITAU = TAU + PI;\nconst INFINITY = Number.POSITIVE_INFINITY;\nconst RAD_PER_DEG = PI / 180;\nconst HALF_PI = PI / 2;\nconst QUARTER_PI = PI / 4;\nconst TWO_THIRDS_PI = PI * 2 / 3;\nconst log10 = Math.log10;\nconst sign = Math.sign;\nfunction niceNum(range) {\n const roundedRange = Math.round(range);\n range = almostEquals(range, roundedRange, range / 1000) ? roundedRange : range;\n const niceRange = Math.pow(10, Math.floor(log10(range)));\n const fraction = range / niceRange;\n const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;\n return niceFraction * niceRange;\n}\nfunction _factorize(value) {\n const result = [];\n const sqrt = Math.sqrt(value);\n let i;\n for (i = 1; i < sqrt; i++) {\n if (value % i === 0) {\n result.push(i);\n result.push(value / i);\n }\n }\n if (sqrt === (sqrt | 0)) {\n result.push(sqrt);\n }\n result.sort((a, b) => a - b).pop();\n return result;\n}\nfunction isNumber(n) {\n return !isNaN(parseFloat(n)) && isFinite(n);\n}\nfunction almostEquals(x, y, epsilon) {\n return Math.abs(x - y) < epsilon;\n}\nfunction almostWhole(x, epsilon) {\n const rounded = Math.round(x);\n return ((rounded - epsilon) <= x) && ((rounded + epsilon) >= x);\n}\nfunction _setMinAndMaxByKey(array, target, property) {\n let i, ilen, value;\n for (i = 0, ilen = array.length; i < ilen; i++) {\n value = array[i][property];\n if (!isNaN(value)) {\n target.min = Math.min(target.min, value);\n target.max = Math.max(target.max, value);\n }\n }\n}\nfunction toRadians(degrees) {\n return degrees * (PI / 180);\n}\nfunction toDegrees(radians) {\n return radians * (180 / PI);\n}\nfunction _decimalPlaces(x) {\n if (!isNumberFinite(x)) {\n return;\n }\n let e = 1;\n let p = 0;\n while (Math.round(x * e) / e !== x) {\n e *= 10;\n p++;\n }\n return p;\n}\nfunction getAngleFromPoint(centrePoint, anglePoint) {\n const distanceFromXCenter = anglePoint.x - centrePoint.x;\n const distanceFromYCenter = anglePoint.y - centrePoint.y;\n const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);\n let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);\n if (angle < (-0.5 * PI)) {\n angle += TAU;\n }\n return {\n angle,\n distance: radialDistanceFromCenter\n };\n}\nfunction distanceBetweenPoints(pt1, pt2) {\n return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));\n}\nfunction _angleDiff(a, b) {\n return (a - b + PITAU) % TAU - PI;\n}\nfunction _normalizeAngle(a) {\n return (a % TAU + TAU) % TAU;\n}\nfunction _angleBetween(angle, start, end, sameAngleIsFullCircle) {\n const a = _normalizeAngle(angle);\n const s = _normalizeAngle(start);\n const e = _normalizeAngle(end);\n const angleToStart = _normalizeAngle(s - a);\n const angleToEnd = _normalizeAngle(e - a);\n const startToAngle = _normalizeAngle(a - s);\n const endToAngle = _normalizeAngle(a - e);\n return a === s || a === e || (sameAngleIsFullCircle && s === e)\n || (angleToStart > angleToEnd && startToAngle < endToAngle);\n}\nfunction _limitValue(value, min, max) {\n return Math.max(min, Math.min(max, value));\n}\nfunction _int16Range(value) {\n return _limitValue(value, -32768, 32767);\n}\nfunction _isBetween(value, start, end, epsilon = 1e-6) {\n return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;\n}\n\nconst atEdge = (t) => t === 0 || t === 1;\nconst elasticIn = (t, s, p) => -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p));\nconst elasticOut = (t, s, p) => Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1;\nconst effects = {\n linear: t => t,\n easeInQuad: t => t * t,\n easeOutQuad: t => -t * (t - 2),\n easeInOutQuad: t => ((t /= 0.5) < 1)\n ? 0.5 * t * t\n : -0.5 * ((--t) * (t - 2) - 1),\n easeInCubic: t => t * t * t,\n easeOutCubic: t => (t -= 1) * t * t + 1,\n easeInOutCubic: t => ((t /= 0.5) < 1)\n ? 0.5 * t * t * t\n : 0.5 * ((t -= 2) * t * t + 2),\n easeInQuart: t => t * t * t * t,\n easeOutQuart: t => -((t -= 1) * t * t * t - 1),\n easeInOutQuart: t => ((t /= 0.5) < 1)\n ? 0.5 * t * t * t * t\n : -0.5 * ((t -= 2) * t * t * t - 2),\n easeInQuint: t => t * t * t * t * t,\n easeOutQuint: t => (t -= 1) * t * t * t * t + 1,\n easeInOutQuint: t => ((t /= 0.5) < 1)\n ? 0.5 * t * t * t * t * t\n : 0.5 * ((t -= 2) * t * t * t * t + 2),\n easeInSine: t => -Math.cos(t * HALF_PI) + 1,\n easeOutSine: t => Math.sin(t * HALF_PI),\n easeInOutSine: t => -0.5 * (Math.cos(PI * t) - 1),\n easeInExpo: t => (t === 0) ? 0 : Math.pow(2, 10 * (t - 1)),\n easeOutExpo: t => (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1,\n easeInOutExpo: t => atEdge(t) ? t : t < 0.5\n ? 0.5 * Math.pow(2, 10 * (t * 2 - 1))\n : 0.5 * (-Math.pow(2, -10 * (t * 2 - 1)) + 2),\n easeInCirc: t => (t >= 1) ? t : -(Math.sqrt(1 - t * t) - 1),\n easeOutCirc: t => Math.sqrt(1 - (t -= 1) * t),\n easeInOutCirc: t => ((t /= 0.5) < 1)\n ? -0.5 * (Math.sqrt(1 - t * t) - 1)\n : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1),\n easeInElastic: t => atEdge(t) ? t : elasticIn(t, 0.075, 0.3),\n easeOutElastic: t => atEdge(t) ? t : elasticOut(t, 0.075, 0.3),\n easeInOutElastic(t) {\n const s = 0.1125;\n const p = 0.45;\n return atEdge(t) ? t :\n t < 0.5\n ? 0.5 * elasticIn(t * 2, s, p)\n : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p);\n },\n easeInBack(t) {\n const s = 1.70158;\n return t * t * ((s + 1) * t - s);\n },\n easeOutBack(t) {\n const s = 1.70158;\n return (t -= 1) * t * ((s + 1) * t + s) + 1;\n },\n easeInOutBack(t) {\n let s = 1.70158;\n if ((t /= 0.5) < 1) {\n return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s));\n }\n return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2);\n },\n easeInBounce: t => 1 - effects.easeOutBounce(1 - t),\n easeOutBounce(t) {\n const m = 7.5625;\n const d = 2.75;\n if (t < (1 / d)) {\n return m * t * t;\n }\n if (t < (2 / d)) {\n return m * (t -= (1.5 / d)) * t + 0.75;\n }\n if (t < (2.5 / d)) {\n return m * (t -= (2.25 / d)) * t + 0.9375;\n }\n return m * (t -= (2.625 / d)) * t + 0.984375;\n },\n easeInOutBounce: t => (t < 0.5)\n ? effects.easeInBounce(t * 2) * 0.5\n : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5,\n};\n\n/*!\n * @kurkle/color v0.2.1\n * https://github.com/kurkle/color#readme\n * (c) 2022 Jukka Kurkela\n * Released under the MIT License\n */\nfunction round(v) {\n return v + 0.5 | 0;\n}\nconst lim = (v, l, h) => Math.max(Math.min(v, h), l);\nfunction p2b(v) {\n return lim(round(v * 2.55), 0, 255);\n}\nfunction n2b(v) {\n return lim(round(v * 255), 0, 255);\n}\nfunction b2n(v) {\n return lim(round(v / 2.55) / 100, 0, 1);\n}\nfunction n2p(v) {\n return lim(round(v * 100), 0, 100);\n}\nconst map$1 = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15};\nconst hex = [...'0123456789ABCDEF'];\nconst h1 = b => hex[b & 0xF];\nconst h2 = b => hex[(b & 0xF0) >> 4] + hex[b & 0xF];\nconst eq = b => ((b & 0xF0) >> 4) === (b & 0xF);\nconst isShort = v => eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a);\nfunction hexParse(str) {\n var len = str.length;\n var ret;\n if (str[0] === '#') {\n if (len === 4 || len === 5) {\n ret = {\n r: 255 & map$1[str[1]] * 17,\n g: 255 & map$1[str[2]] * 17,\n b: 255 & map$1[str[3]] * 17,\n a: len === 5 ? map$1[str[4]] * 17 : 255\n };\n } else if (len === 7 || len === 9) {\n ret = {\n r: map$1[str[1]] << 4 | map$1[str[2]],\n g: map$1[str[3]] << 4 | map$1[str[4]],\n b: map$1[str[5]] << 4 | map$1[str[6]],\n a: len === 9 ? (map$1[str[7]] << 4 | map$1[str[8]]) : 255\n };\n }\n }\n return ret;\n}\nconst alpha = (a, f) => a < 255 ? f(a) : '';\nfunction hexString(v) {\n var f = isShort(v) ? h1 : h2;\n return v\n ? '#' + f(v.r) + f(v.g) + f(v.b) + alpha(v.a, f)\n : undefined;\n}\nconst HUE_RE = /^(hsla?|hwb|hsv)\\(\\s*([-+.e\\d]+)(?:deg)?[\\s,]+([-+.e\\d]+)%[\\s,]+([-+.e\\d]+)%(?:[\\s,]+([-+.e\\d]+)(%)?)?\\s*\\)$/;\nfunction hsl2rgbn(h, s, l) {\n const a = s * Math.min(l, 1 - l);\n const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);\n return [f(0), f(8), f(4)];\n}\nfunction hsv2rgbn(h, s, v) {\n const f = (n, k = (n + h / 60) % 6) => v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);\n return [f(5), f(3), f(1)];\n}\nfunction hwb2rgbn(h, w, b) {\n const rgb = hsl2rgbn(h, 1, 0.5);\n let i;\n if (w + b > 1) {\n i = 1 / (w + b);\n w *= i;\n b *= i;\n }\n for (i = 0; i < 3; i++) {\n rgb[i] *= 1 - w - b;\n rgb[i] += w;\n }\n return rgb;\n}\nfunction hueValue(r, g, b, d, max) {\n if (r === max) {\n return ((g - b) / d) + (g < b ? 6 : 0);\n }\n if (g === max) {\n return (b - r) / d + 2;\n }\n return (r - g) / d + 4;\n}\nfunction rgb2hsl(v) {\n const range = 255;\n const r = v.r / range;\n const g = v.g / range;\n const b = v.b / range;\n const max = Math.max(r, g, b);\n const min = Math.min(r, g, b);\n const l = (max + min) / 2;\n let h, s, d;\n if (max !== min) {\n d = max - min;\n s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n h = hueValue(r, g, b, d, max);\n h = h * 60 + 0.5;\n }\n return [h | 0, s || 0, l];\n}\nfunction calln(f, a, b, c) {\n return (\n Array.isArray(a)\n ? f(a[0], a[1], a[2])\n : f(a, b, c)\n ).map(n2b);\n}\nfunction hsl2rgb(h, s, l) {\n return calln(hsl2rgbn, h, s, l);\n}\nfunction hwb2rgb(h, w, b) {\n return calln(hwb2rgbn, h, w, b);\n}\nfunction hsv2rgb(h, s, v) {\n return calln(hsv2rgbn, h, s, v);\n}\nfunction hue(h) {\n return (h % 360 + 360) % 360;\n}\nfunction hueParse(str) {\n const m = HUE_RE.exec(str);\n let a = 255;\n let v;\n if (!m) {\n return;\n }\n if (m[5] !== v) {\n a = m[6] ? p2b(+m[5]) : n2b(+m[5]);\n }\n const h = hue(+m[2]);\n const p1 = +m[3] / 100;\n const p2 = +m[4] / 100;\n if (m[1] === 'hwb') {\n v = hwb2rgb(h, p1, p2);\n } else if (m[1] === 'hsv') {\n v = hsv2rgb(h, p1, p2);\n } else {\n v = hsl2rgb(h, p1, p2);\n }\n return {\n r: v[0],\n g: v[1],\n b: v[2],\n a: a\n };\n}\nfunction rotate(v, deg) {\n var h = rgb2hsl(v);\n h[0] = hue(h[0] + deg);\n h = hsl2rgb(h);\n v.r = h[0];\n v.g = h[1];\n v.b = h[2];\n}\nfunction hslString(v) {\n if (!v) {\n return;\n }\n const a = rgb2hsl(v);\n const h = a[0];\n const s = n2p(a[1]);\n const l = n2p(a[2]);\n return v.a < 255\n ? `hsla(${h}, ${s}%, ${l}%, ${b2n(v.a)})`\n : `hsl(${h}, ${s}%, ${l}%)`;\n}\nconst map = {\n x: 'dark',\n Z: 'light',\n Y: 're',\n X: 'blu',\n W: 'gr',\n V: 'medium',\n U: 'slate',\n A: 'ee',\n T: 'ol',\n S: 'or',\n B: 'ra',\n C: 'lateg',\n D: 'ights',\n R: 'in',\n Q: 'turquois',\n E: 'hi',\n P: 'ro',\n O: 'al',\n N: 'le',\n M: 'de',\n L: 'yello',\n F: 'en',\n K: 'ch',\n G: 'arks',\n H: 'ea',\n I: 'ightg',\n J: 'wh'\n};\nconst names$1 = {\n OiceXe: 'f0f8ff',\n antiquewEte: 'faebd7',\n aqua: 'ffff',\n aquamarRe: '7fffd4',\n azuY: 'f0ffff',\n beige: 'f5f5dc',\n bisque: 'ffe4c4',\n black: '0',\n blanKedOmond: 'ffebcd',\n Xe: 'ff',\n XeviTet: '8a2be2',\n bPwn: 'a52a2a',\n burlywood: 'deb887',\n caMtXe: '5f9ea0',\n KartYuse: '7fff00',\n KocTate: 'd2691e',\n cSO: 'ff7f50',\n cSnflowerXe: '6495ed',\n cSnsilk: 'fff8dc',\n crimson: 'dc143c',\n cyan: 'ffff',\n xXe: '8b',\n xcyan: '8b8b',\n xgTMnPd: 'b8860b',\n xWay: 'a9a9a9',\n xgYF: '6400',\n xgYy: 'a9a9a9',\n xkhaki: 'bdb76b',\n xmagFta: '8b008b',\n xTivegYF: '556b2f',\n xSange: 'ff8c00',\n xScEd: '9932cc',\n xYd: '8b0000',\n xsOmon: 'e9967a',\n xsHgYF: '8fbc8f',\n xUXe: '483d8b',\n xUWay: '2f4f4f',\n xUgYy: '2f4f4f',\n xQe: 'ced1',\n xviTet: '9400d3',\n dAppRk: 'ff1493',\n dApskyXe: 'bfff',\n dimWay: '696969',\n dimgYy: '696969',\n dodgerXe: '1e90ff',\n fiYbrick: 'b22222',\n flSOwEte: 'fffaf0',\n foYstWAn: '228b22',\n fuKsia: 'ff00ff',\n gaRsbSo: 'dcdcdc',\n ghostwEte: 'f8f8ff',\n gTd: 'ffd700',\n gTMnPd: 'daa520',\n Way: '808080',\n gYF: '8000',\n gYFLw: 'adff2f',\n gYy: '808080',\n honeyMw: 'f0fff0',\n hotpRk: 'ff69b4',\n RdianYd: 'cd5c5c',\n Rdigo: '4b0082',\n ivSy: 'fffff0',\n khaki: 'f0e68c',\n lavFMr: 'e6e6fa',\n lavFMrXsh: 'fff0f5',\n lawngYF: '7cfc00',\n NmoncEffon: 'fffacd',\n ZXe: 'add8e6',\n ZcSO: 'f08080',\n Zcyan: 'e0ffff',\n ZgTMnPdLw: 'fafad2',\n ZWay: 'd3d3d3',\n ZgYF: '90ee90',\n ZgYy: 'd3d3d3',\n ZpRk: 'ffb6c1',\n ZsOmon: 'ffa07a',\n ZsHgYF: '20b2aa',\n ZskyXe: '87cefa',\n ZUWay: '778899',\n ZUgYy: '778899',\n ZstAlXe: 'b0c4de',\n ZLw: 'ffffe0',\n lime: 'ff00',\n limegYF: '32cd32',\n lRF: 'faf0e6',\n magFta: 'ff00ff',\n maPon: '800000',\n VaquamarRe: '66cdaa',\n VXe: 'cd',\n VScEd: 'ba55d3',\n VpurpN: '9370db',\n VsHgYF: '3cb371',\n VUXe: '7b68ee',\n VsprRggYF: 'fa9a',\n VQe: '48d1cc',\n VviTetYd: 'c71585',\n midnightXe: '191970',\n mRtcYam: 'f5fffa',\n mistyPse: 'ffe4e1',\n moccasR: 'ffe4b5',\n navajowEte: 'ffdead',\n navy: '80',\n Tdlace: 'fdf5e6',\n Tive: '808000',\n TivedBb: '6b8e23',\n Sange: 'ffa500',\n SangeYd: 'ff4500',\n ScEd: 'da70d6',\n pOegTMnPd: 'eee8aa',\n pOegYF: '98fb98',\n pOeQe: 'afeeee',\n pOeviTetYd: 'db7093',\n papayawEp: 'ffefd5',\n pHKpuff: 'ffdab9',\n peru: 'cd853f',\n pRk: 'ffc0cb',\n plum: 'dda0dd',\n powMrXe: 'b0e0e6',\n purpN: '800080',\n YbeccapurpN: '663399',\n Yd: 'ff0000',\n Psybrown: 'bc8f8f',\n PyOXe: '4169e1',\n saddNbPwn: '8b4513',\n sOmon: 'fa8072',\n sandybPwn: 'f4a460',\n sHgYF: '2e8b57',\n sHshell: 'fff5ee',\n siFna: 'a0522d',\n silver: 'c0c0c0',\n skyXe: '87ceeb',\n UXe: '6a5acd',\n UWay: '708090',\n UgYy: '708090',\n snow: 'fffafa',\n sprRggYF: 'ff7f',\n stAlXe: '4682b4',\n tan: 'd2b48c',\n teO: '8080',\n tEstN: 'd8bfd8',\n tomato: 'ff6347',\n Qe: '40e0d0',\n viTet: 'ee82ee',\n JHt: 'f5deb3',\n wEte: 'ffffff',\n wEtesmoke: 'f5f5f5',\n Lw: 'ffff00',\n LwgYF: '9acd32'\n};\nfunction unpack() {\n const unpacked = {};\n const keys = Object.keys(names$1);\n const tkeys = Object.keys(map);\n let i, j, k, ok, nk;\n for (i = 0; i < keys.length; i++) {\n ok = nk = keys[i];\n for (j = 0; j < tkeys.length; j++) {\n k = tkeys[j];\n nk = nk.replace(k, map[k]);\n }\n k = parseInt(names$1[ok], 16);\n unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF];\n }\n return unpacked;\n}\nlet names;\nfunction nameParse(str) {\n if (!names) {\n names = unpack();\n names.transparent = [0, 0, 0, 0];\n }\n const a = names[str.toLowerCase()];\n return a && {\n r: a[0],\n g: a[1],\n b: a[2],\n a: a.length === 4 ? a[3] : 255\n };\n}\nconst RGB_RE = /^rgba?\\(\\s*([-+.\\d]+)(%)?[\\s,]+([-+.e\\d]+)(%)?[\\s,]+([-+.e\\d]+)(%)?(?:[\\s,/]+([-+.e\\d]+)(%)?)?\\s*\\)$/;\nfunction rgbParse(str) {\n const m = RGB_RE.exec(str);\n let a = 255;\n let r, g, b;\n if (!m) {\n return;\n }\n if (m[7] !== r) {\n const v = +m[7];\n a = m[8] ? p2b(v) : lim(v * 255, 0, 255);\n }\n r = +m[1];\n g = +m[3];\n b = +m[5];\n r = 255 & (m[2] ? p2b(r) : lim(r, 0, 255));\n g = 255 & (m[4] ? p2b(g) : lim(g, 0, 255));\n b = 255 & (m[6] ? p2b(b) : lim(b, 0, 255));\n return {\n r: r,\n g: g,\n b: b,\n a: a\n };\n}\nfunction rgbString(v) {\n return v && (\n v.a < 255\n ? `rgba(${v.r}, ${v.g}, ${v.b}, ${b2n(v.a)})`\n : `rgb(${v.r}, ${v.g}, ${v.b})`\n );\n}\nconst to = v => v <= 0.0031308 ? v * 12.92 : Math.pow(v, 1.0 / 2.4) * 1.055 - 0.055;\nconst from = v => v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);\nfunction interpolate(rgb1, rgb2, t) {\n const r = from(b2n(rgb1.r));\n const g = from(b2n(rgb1.g));\n const b = from(b2n(rgb1.b));\n return {\n r: n2b(to(r + t * (from(b2n(rgb2.r)) - r))),\n g: n2b(to(g + t * (from(b2n(rgb2.g)) - g))),\n b: n2b(to(b + t * (from(b2n(rgb2.b)) - b))),\n a: rgb1.a + t * (rgb2.a - rgb1.a)\n };\n}\nfunction modHSL(v, i, ratio) {\n if (v) {\n let tmp = rgb2hsl(v);\n tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1));\n tmp = hsl2rgb(tmp);\n v.r = tmp[0];\n v.g = tmp[1];\n v.b = tmp[2];\n }\n}\nfunction clone(v, proto) {\n return v ? Object.assign(proto || {}, v) : v;\n}\nfunction fromObject(input) {\n var v = {r: 0, g: 0, b: 0, a: 255};\n if (Array.isArray(input)) {\n if (input.length >= 3) {\n v = {r: input[0], g: input[1], b: input[2], a: 255};\n if (input.length > 3) {\n v.a = n2b(input[3]);\n }\n }\n } else {\n v = clone(input, {r: 0, g: 0, b: 0, a: 1});\n v.a = n2b(v.a);\n }\n return v;\n}\nfunction functionParse(str) {\n if (str.charAt(0) === 'r') {\n return rgbParse(str);\n }\n return hueParse(str);\n}\nclass Color {\n constructor(input) {\n if (input instanceof Color) {\n return input;\n }\n const type = typeof input;\n let v;\n if (type === 'object') {\n v = fromObject(input);\n } else if (type === 'string') {\n v = hexParse(input) || nameParse(input) || functionParse(input);\n }\n this._rgb = v;\n this._valid = !!v;\n }\n get valid() {\n return this._valid;\n }\n get rgb() {\n var v = clone(this._rgb);\n if (v) {\n v.a = b2n(v.a);\n }\n return v;\n }\n set rgb(obj) {\n this._rgb = fromObject(obj);\n }\n rgbString() {\n return this._valid ? rgbString(this._rgb) : undefined;\n }\n hexString() {\n return this._valid ? hexString(this._rgb) : undefined;\n }\n hslString() {\n return this._valid ? hslString(this._rgb) : undefined;\n }\n mix(color, weight) {\n if (color) {\n const c1 = this.rgb;\n const c2 = color.rgb;\n let w2;\n const p = weight === w2 ? 0.5 : weight;\n const w = 2 * p - 1;\n const a = c1.a - c2.a;\n const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0;\n w2 = 1 - w1;\n c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5;\n c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5;\n c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5;\n c1.a = p * c1.a + (1 - p) * c2.a;\n this.rgb = c1;\n }\n return this;\n }\n interpolate(color, t) {\n if (color) {\n this._rgb = interpolate(this._rgb, color._rgb, t);\n }\n return this;\n }\n clone() {\n return new Color(this.rgb);\n }\n alpha(a) {\n this._rgb.a = n2b(a);\n return this;\n }\n clearer(ratio) {\n const rgb = this._rgb;\n rgb.a *= 1 - ratio;\n return this;\n }\n greyscale() {\n const rgb = this._rgb;\n const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);\n rgb.r = rgb.g = rgb.b = val;\n return this;\n }\n opaquer(ratio) {\n const rgb = this._rgb;\n rgb.a *= 1 + ratio;\n return this;\n }\n negate() {\n const v = this._rgb;\n v.r = 255 - v.r;\n v.g = 255 - v.g;\n v.b = 255 - v.b;\n return this;\n }\n lighten(ratio) {\n modHSL(this._rgb, 2, ratio);\n return this;\n }\n darken(ratio) {\n modHSL(this._rgb, 2, -ratio);\n return this;\n }\n saturate(ratio) {\n modHSL(this._rgb, 1, ratio);\n return this;\n }\n desaturate(ratio) {\n modHSL(this._rgb, 1, -ratio);\n return this;\n }\n rotate(deg) {\n rotate(this._rgb, deg);\n return this;\n }\n}\nfunction index_esm(input) {\n return new Color(input);\n}\n\nfunction isPatternOrGradient(value) {\n if (value && typeof value === 'object') {\n const type = value.toString();\n return type === '[object CanvasPattern]' || type === '[object CanvasGradient]';\n }\n return false;\n}\nfunction color(value) {\n return isPatternOrGradient(value) ? value : index_esm(value);\n}\nfunction getHoverColor(value) {\n return isPatternOrGradient(value)\n ? value\n : index_esm(value).saturate(0.5).darken(0.1).hexString();\n}\n\nconst overrides = Object.create(null);\nconst descriptors = Object.create(null);\nfunction getScope$1(node, key) {\n if (!key) {\n return node;\n }\n const keys = key.split('.');\n for (let i = 0, n = keys.length; i < n; ++i) {\n const k = keys[i];\n node = node[k] || (node[k] = Object.create(null));\n }\n return node;\n}\nfunction set(root, scope, values) {\n if (typeof scope === 'string') {\n return merge(getScope$1(root, scope), values);\n }\n return merge(getScope$1(root, ''), scope);\n}\nclass Defaults {\n constructor(_descriptors) {\n this.animation = undefined;\n this.backgroundColor = 'rgba(0,0,0,0.1)';\n this.borderColor = 'rgba(0,0,0,0.1)';\n this.color = '#666';\n this.datasets = {};\n this.devicePixelRatio = (context) => context.chart.platform.getDevicePixelRatio();\n this.elements = {};\n this.events = [\n 'mousemove',\n 'mouseout',\n 'click',\n 'touchstart',\n 'touchmove'\n ];\n this.font = {\n family: \"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif\",\n size: 12,\n style: 'normal',\n lineHeight: 1.2,\n weight: null\n };\n this.hover = {};\n this.hoverBackgroundColor = (ctx, options) => getHoverColor(options.backgroundColor);\n this.hoverBorderColor = (ctx, options) => getHoverColor(options.borderColor);\n this.hoverColor = (ctx, options) => getHoverColor(options.color);\n this.indexAxis = 'x';\n this.interaction = {\n mode: 'nearest',\n intersect: true,\n includeInvisible: false\n };\n this.maintainAspectRatio = true;\n this.onHover = null;\n this.onClick = null;\n this.parsing = true;\n this.plugins = {};\n this.responsive = true;\n this.scale = undefined;\n this.scales = {};\n this.showLine = true;\n this.drawActiveElementsOnTop = true;\n this.describe(_descriptors);\n }\n set(scope, values) {\n return set(this, scope, values);\n }\n get(scope) {\n return getScope$1(this, scope);\n }\n describe(scope, values) {\n return set(descriptors, scope, values);\n }\n override(scope, values) {\n return set(overrides, scope, values);\n }\n route(scope, name, targetScope, targetName) {\n const scopeObject = getScope$1(this, scope);\n const targetScopeObject = getScope$1(this, targetScope);\n const privateName = '_' + name;\n Object.defineProperties(scopeObject, {\n [privateName]: {\n value: scopeObject[name],\n writable: true\n },\n [name]: {\n enumerable: true,\n get() {\n const local = this[privateName];\n const target = targetScopeObject[targetName];\n if (isObject(local)) {\n return Object.assign({}, target, local);\n }\n return valueOrDefault(local, target);\n },\n set(value) {\n this[privateName] = value;\n }\n }\n });\n }\n}\nvar defaults = new Defaults({\n _scriptable: (name) => !name.startsWith('on'),\n _indexable: (name) => name !== 'events',\n hover: {\n _fallback: 'interaction'\n },\n interaction: {\n _scriptable: false,\n _indexable: false,\n }\n});\n\nfunction toFontString(font) {\n if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {\n return null;\n }\n return (font.style ? font.style + ' ' : '')\n\t\t+ (font.weight ? font.weight + ' ' : '')\n\t\t+ font.size + 'px '\n\t\t+ font.family;\n}\nfunction _measureText(ctx, data, gc, longest, string) {\n let textWidth = data[string];\n if (!textWidth) {\n textWidth = data[string] = ctx.measureText(string).width;\n gc.push(string);\n }\n if (textWidth > longest) {\n longest = textWidth;\n }\n return longest;\n}\nfunction _longestText(ctx, font, arrayOfThings, cache) {\n cache = cache || {};\n let data = cache.data = cache.data || {};\n let gc = cache.garbageCollect = cache.garbageCollect || [];\n if (cache.font !== font) {\n data = cache.data = {};\n gc = cache.garbageCollect = [];\n cache.font = font;\n }\n ctx.save();\n ctx.font = font;\n let longest = 0;\n const ilen = arrayOfThings.length;\n let i, j, jlen, thing, nestedThing;\n for (i = 0; i < ilen; i++) {\n thing = arrayOfThings[i];\n if (thing !== undefined && thing !== null && isArray(thing) !== true) {\n longest = _measureText(ctx, data, gc, longest, thing);\n } else if (isArray(thing)) {\n for (j = 0, jlen = thing.length; j < jlen; j++) {\n nestedThing = thing[j];\n if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) {\n longest = _measureText(ctx, data, gc, longest, nestedThing);\n }\n }\n }\n }\n ctx.restore();\n const gcLen = gc.length / 2;\n if (gcLen > arrayOfThings.length) {\n for (i = 0; i < gcLen; i++) {\n delete data[gc[i]];\n }\n gc.splice(0, gcLen);\n }\n return longest;\n}\nfunction _alignPixel(chart, pixel, width) {\n const devicePixelRatio = chart.currentDevicePixelRatio;\n const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;\n return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;\n}\nfunction clearCanvas(canvas, ctx) {\n ctx = ctx || canvas.getContext('2d');\n ctx.save();\n ctx.resetTransform();\n ctx.clearRect(0, 0, canvas.width, canvas.height);\n ctx.restore();\n}\nfunction drawPoint(ctx, options, x, y) {\n let type, xOffset, yOffset, size, cornerRadius;\n const style = options.pointStyle;\n const rotation = options.rotation;\n const radius = options.radius;\n let rad = (rotation || 0) * RAD_PER_DEG;\n if (style && typeof style === 'object') {\n type = style.toString();\n if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {\n ctx.save();\n ctx.translate(x, y);\n ctx.rotate(rad);\n ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);\n ctx.restore();\n return;\n }\n }\n if (isNaN(radius) || radius <= 0) {\n return;\n }\n ctx.beginPath();\n switch (style) {\n default:\n ctx.arc(x, y, radius, 0, TAU);\n ctx.closePath();\n break;\n case 'triangle':\n ctx.moveTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);\n rad += TWO_THIRDS_PI;\n ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);\n rad += TWO_THIRDS_PI;\n ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);\n ctx.closePath();\n break;\n case 'rectRounded':\n cornerRadius = radius * 0.516;\n size = radius - cornerRadius;\n xOffset = Math.cos(rad + QUARTER_PI) * size;\n yOffset = Math.sin(rad + QUARTER_PI) * size;\n ctx.arc(x - xOffset, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI);\n ctx.arc(x + yOffset, y - xOffset, cornerRadius, rad - HALF_PI, rad);\n ctx.arc(x + xOffset, y + yOffset, cornerRadius, rad, rad + HALF_PI);\n ctx.arc(x - yOffset, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI);\n ctx.closePath();\n break;\n case 'rect':\n if (!rotation) {\n size = Math.SQRT1_2 * radius;\n ctx.rect(x - size, y - size, 2 * size, 2 * size);\n break;\n }\n rad += QUARTER_PI;\n case 'rectRot':\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + yOffset, y - xOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n ctx.lineTo(x - yOffset, y + xOffset);\n ctx.closePath();\n break;\n case 'crossRot':\n rad += QUARTER_PI;\n case 'cross':\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n ctx.moveTo(x + yOffset, y - xOffset);\n ctx.lineTo(x - yOffset, y + xOffset);\n break;\n case 'star':\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n ctx.moveTo(x + yOffset, y - xOffset);\n ctx.lineTo(x - yOffset, y + xOffset);\n rad += QUARTER_PI;\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n ctx.moveTo(x + yOffset, y - xOffset);\n ctx.lineTo(x - yOffset, y + xOffset);\n break;\n case 'line':\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n break;\n case 'dash':\n ctx.moveTo(x, y);\n ctx.lineTo(x + Math.cos(rad) * radius, y + Math.sin(rad) * radius);\n break;\n }\n ctx.fill();\n if (options.borderWidth > 0) {\n ctx.stroke();\n }\n}\nfunction _isPointInArea(point, area, margin) {\n margin = margin || 0.5;\n return !area || (point && point.x > area.left - margin && point.x < area.right + margin &&\n\t\tpoint.y > area.top - margin && point.y < area.bottom + margin);\n}\nfunction clipArea(ctx, area) {\n ctx.save();\n ctx.beginPath();\n ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);\n ctx.clip();\n}\nfunction unclipArea(ctx) {\n ctx.restore();\n}\nfunction _steppedLineTo(ctx, previous, target, flip, mode) {\n if (!previous) {\n return ctx.lineTo(target.x, target.y);\n }\n if (mode === 'middle') {\n const midpoint = (previous.x + target.x) / 2.0;\n ctx.lineTo(midpoint, previous.y);\n ctx.lineTo(midpoint, target.y);\n } else if (mode === 'after' !== !!flip) {\n ctx.lineTo(previous.x, target.y);\n } else {\n ctx.lineTo(target.x, previous.y);\n }\n ctx.lineTo(target.x, target.y);\n}\nfunction _bezierCurveTo(ctx, previous, target, flip) {\n if (!previous) {\n return ctx.lineTo(target.x, target.y);\n }\n ctx.bezierCurveTo(\n flip ? previous.cp1x : previous.cp2x,\n flip ? previous.cp1y : previous.cp2y,\n flip ? target.cp2x : target.cp1x,\n flip ? target.cp2y : target.cp1y,\n target.x,\n target.y);\n}\nfunction renderText(ctx, text, x, y, font, opts = {}) {\n const lines = isArray(text) ? text : [text];\n const stroke = opts.strokeWidth > 0 && opts.strokeColor !== '';\n let i, line;\n ctx.save();\n ctx.font = font.string;\n setRenderOpts(ctx, opts);\n for (i = 0; i < lines.length; ++i) {\n line = lines[i];\n if (stroke) {\n if (opts.strokeColor) {\n ctx.strokeStyle = opts.strokeColor;\n }\n if (!isNullOrUndef(opts.strokeWidth)) {\n ctx.lineWidth = opts.strokeWidth;\n }\n ctx.strokeText(line, x, y, opts.maxWidth);\n }\n ctx.fillText(line, x, y, opts.maxWidth);\n decorateText(ctx, x, y, line, opts);\n y += font.lineHeight;\n }\n ctx.restore();\n}\nfunction setRenderOpts(ctx, opts) {\n if (opts.translation) {\n ctx.translate(opts.translation[0], opts.translation[1]);\n }\n if (!isNullOrUndef(opts.rotation)) {\n ctx.rotate(opts.rotation);\n }\n if (opts.color) {\n ctx.fillStyle = opts.color;\n }\n if (opts.textAlign) {\n ctx.textAlign = opts.textAlign;\n }\n if (opts.textBaseline) {\n ctx.textBaseline = opts.textBaseline;\n }\n}\nfunction decorateText(ctx, x, y, line, opts) {\n if (opts.strikethrough || opts.underline) {\n const metrics = ctx.measureText(line);\n const left = x - metrics.actualBoundingBoxLeft;\n const right = x + metrics.actualBoundingBoxRight;\n const top = y - metrics.actualBoundingBoxAscent;\n const bottom = y + metrics.actualBoundingBoxDescent;\n const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;\n ctx.strokeStyle = ctx.fillStyle;\n ctx.beginPath();\n ctx.lineWidth = opts.decorationWidth || 2;\n ctx.moveTo(left, yDecoration);\n ctx.lineTo(right, yDecoration);\n ctx.stroke();\n }\n}\nfunction addRoundedRectPath(ctx, rect) {\n const {x, y, w, h, radius} = rect;\n ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, -HALF_PI, PI, true);\n ctx.lineTo(x, y + h - radius.bottomLeft);\n ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);\n ctx.lineTo(x + w - radius.bottomRight, y + h);\n ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);\n ctx.lineTo(x + w, y + radius.topRight);\n ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true);\n ctx.lineTo(x + radius.topLeft, y);\n}\n\nconst LINE_HEIGHT = new RegExp(/^(normal|(\\d+(?:\\.\\d+)?)(px|em|%)?)$/);\nconst FONT_STYLE = new RegExp(/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/);\nfunction toLineHeight(value, size) {\n const matches = ('' + value).match(LINE_HEIGHT);\n if (!matches || matches[1] === 'normal') {\n return size * 1.2;\n }\n value = +matches[2];\n switch (matches[3]) {\n case 'px':\n return value;\n case '%':\n value /= 100;\n break;\n }\n return size * value;\n}\nconst numberOrZero = v => +v || 0;\nfunction _readValueToProps(value, props) {\n const ret = {};\n const objProps = isObject(props);\n const keys = objProps ? Object.keys(props) : props;\n const read = isObject(value)\n ? objProps\n ? prop => valueOrDefault(value[prop], value[props[prop]])\n : prop => value[prop]\n : () => value;\n for (const prop of keys) {\n ret[prop] = numberOrZero(read(prop));\n }\n return ret;\n}\nfunction toTRBL(value) {\n return _readValueToProps(value, {top: 'y', right: 'x', bottom: 'y', left: 'x'});\n}\nfunction toTRBLCorners(value) {\n return _readValueToProps(value, ['topLeft', 'topRight', 'bottomLeft', 'bottomRight']);\n}\nfunction toPadding(value) {\n const obj = toTRBL(value);\n obj.width = obj.left + obj.right;\n obj.height = obj.top + obj.bottom;\n return obj;\n}\nfunction toFont(options, fallback) {\n options = options || {};\n fallback = fallback || defaults.font;\n let size = valueOrDefault(options.size, fallback.size);\n if (typeof size === 'string') {\n size = parseInt(size, 10);\n }\n let style = valueOrDefault(options.style, fallback.style);\n if (style && !('' + style).match(FONT_STYLE)) {\n console.warn('Invalid font style specified: \"' + style + '\"');\n style = '';\n }\n const font = {\n family: valueOrDefault(options.family, fallback.family),\n lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),\n size,\n style,\n weight: valueOrDefault(options.weight, fallback.weight),\n string: ''\n };\n font.string = toFontString(font);\n return font;\n}\nfunction resolve(inputs, context, index, info) {\n let cacheable = true;\n let i, ilen, value;\n for (i = 0, ilen = inputs.length; i < ilen; ++i) {\n value = inputs[i];\n if (value === undefined) {\n continue;\n }\n if (context !== undefined && typeof value === 'function') {\n value = value(context);\n cacheable = false;\n }\n if (index !== undefined && isArray(value)) {\n value = value[index % value.length];\n cacheable = false;\n }\n if (value !== undefined) {\n if (info && !cacheable) {\n info.cacheable = false;\n }\n return value;\n }\n }\n}\nfunction _addGrace(minmax, grace, beginAtZero) {\n const {min, max} = minmax;\n const change = toDimension(grace, (max - min) / 2);\n const keepZero = (value, add) => beginAtZero && value === 0 ? 0 : value + add;\n return {\n min: keepZero(min, -Math.abs(change)),\n max: keepZero(max, change)\n };\n}\nfunction createContext(parentContext, context) {\n return Object.assign(Object.create(parentContext), context);\n}\n\nfunction _lookup(table, value, cmp) {\n cmp = cmp || ((index) => table[index] < value);\n let hi = table.length - 1;\n let lo = 0;\n let mid;\n while (hi - lo > 1) {\n mid = (lo + hi) >> 1;\n if (cmp(mid)) {\n lo = mid;\n } else {\n hi = mid;\n }\n }\n return {lo, hi};\n}\nconst _lookupByKey = (table, key, value) =>\n _lookup(table, value, index => table[index][key] < value);\nconst _rlookupByKey = (table, key, value) =>\n _lookup(table, value, index => table[index][key] >= value);\nfunction _filterBetween(values, min, max) {\n let start = 0;\n let end = values.length;\n while (start < end && values[start] < min) {\n start++;\n }\n while (end > start && values[end - 1] > max) {\n end--;\n }\n return start > 0 || end < values.length\n ? values.slice(start, end)\n : values;\n}\nconst arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift'];\nfunction listenArrayEvents(array, listener) {\n if (array._chartjs) {\n array._chartjs.listeners.push(listener);\n return;\n }\n Object.defineProperty(array, '_chartjs', {\n configurable: true,\n enumerable: false,\n value: {\n listeners: [listener]\n }\n });\n arrayEvents.forEach((key) => {\n const method = '_onData' + _capitalize(key);\n const base = array[key];\n Object.defineProperty(array, key, {\n configurable: true,\n enumerable: false,\n value(...args) {\n const res = base.apply(this, args);\n array._chartjs.listeners.forEach((object) => {\n if (typeof object[method] === 'function') {\n object[method](...args);\n }\n });\n return res;\n }\n });\n });\n}\nfunction unlistenArrayEvents(array, listener) {\n const stub = array._chartjs;\n if (!stub) {\n return;\n }\n const listeners = stub.listeners;\n const index = listeners.indexOf(listener);\n if (index !== -1) {\n listeners.splice(index, 1);\n }\n if (listeners.length > 0) {\n return;\n }\n arrayEvents.forEach((key) => {\n delete array[key];\n });\n delete array._chartjs;\n}\nfunction _arrayUnique(items) {\n const set = new Set();\n let i, ilen;\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n set.add(items[i]);\n }\n if (set.size === ilen) {\n return items;\n }\n return Array.from(set);\n}\n\nfunction _createResolver(scopes, prefixes = [''], rootScopes = scopes, fallback, getTarget = () => scopes[0]) {\n if (!defined(fallback)) {\n fallback = _resolve('_fallback', scopes);\n }\n const cache = {\n [Symbol.toStringTag]: 'Object',\n _cacheable: true,\n _scopes: scopes,\n _rootScopes: rootScopes,\n _fallback: fallback,\n _getTarget: getTarget,\n override: (scope) => _createResolver([scope, ...scopes], prefixes, rootScopes, fallback),\n };\n return new Proxy(cache, {\n deleteProperty(target, prop) {\n delete target[prop];\n delete target._keys;\n delete scopes[0][prop];\n return true;\n },\n get(target, prop) {\n return _cached(target, prop,\n () => _resolveWithPrefixes(prop, prefixes, scopes, target));\n },\n getOwnPropertyDescriptor(target, prop) {\n return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);\n },\n getPrototypeOf() {\n return Reflect.getPrototypeOf(scopes[0]);\n },\n has(target, prop) {\n return getKeysFromAllScopes(target).includes(prop);\n },\n ownKeys(target) {\n return getKeysFromAllScopes(target);\n },\n set(target, prop, value) {\n const storage = target._storage || (target._storage = getTarget());\n target[prop] = storage[prop] = value;\n delete target._keys;\n return true;\n }\n });\n}\nfunction _attachContext(proxy, context, subProxy, descriptorDefaults) {\n const cache = {\n _cacheable: false,\n _proxy: proxy,\n _context: context,\n _subProxy: subProxy,\n _stack: new Set(),\n _descriptors: _descriptors(proxy, descriptorDefaults),\n setContext: (ctx) => _attachContext(proxy, ctx, subProxy, descriptorDefaults),\n override: (scope) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)\n };\n return new Proxy(cache, {\n deleteProperty(target, prop) {\n delete target[prop];\n delete proxy[prop];\n return true;\n },\n get(target, prop, receiver) {\n return _cached(target, prop,\n () => _resolveWithContext(target, prop, receiver));\n },\n getOwnPropertyDescriptor(target, prop) {\n return target._descriptors.allKeys\n ? Reflect.has(proxy, prop) ? {enumerable: true, configurable: true} : undefined\n : Reflect.getOwnPropertyDescriptor(proxy, prop);\n },\n getPrototypeOf() {\n return Reflect.getPrototypeOf(proxy);\n },\n has(target, prop) {\n return Reflect.has(proxy, prop);\n },\n ownKeys() {\n return Reflect.ownKeys(proxy);\n },\n set(target, prop, value) {\n proxy[prop] = value;\n delete target[prop];\n return true;\n }\n });\n}\nfunction _descriptors(proxy, defaults = {scriptable: true, indexable: true}) {\n const {_scriptable = defaults.scriptable, _indexable = defaults.indexable, _allKeys = defaults.allKeys} = proxy;\n return {\n allKeys: _allKeys,\n scriptable: _scriptable,\n indexable: _indexable,\n isScriptable: isFunction(_scriptable) ? _scriptable : () => _scriptable,\n isIndexable: isFunction(_indexable) ? _indexable : () => _indexable\n };\n}\nconst readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name;\nconst needsSubResolver = (prop, value) => isObject(value) && prop !== 'adapters' &&\n (Object.getPrototypeOf(value) === null || value.constructor === Object);\nfunction _cached(target, prop, resolve) {\n if (Object.prototype.hasOwnProperty.call(target, prop)) {\n return target[prop];\n }\n const value = resolve();\n target[prop] = value;\n return value;\n}\nfunction _resolveWithContext(target, prop, receiver) {\n const {_proxy, _context, _subProxy, _descriptors: descriptors} = target;\n let value = _proxy[prop];\n if (isFunction(value) && descriptors.isScriptable(prop)) {\n value = _resolveScriptable(prop, value, target, receiver);\n }\n if (isArray(value) && value.length) {\n value = _resolveArray(prop, value, target, descriptors.isIndexable);\n }\n if (needsSubResolver(prop, value)) {\n value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors);\n }\n return value;\n}\nfunction _resolveScriptable(prop, value, target, receiver) {\n const {_proxy, _context, _subProxy, _stack} = target;\n if (_stack.has(prop)) {\n throw new Error('Recursion detected: ' + Array.from(_stack).join('->') + '->' + prop);\n }\n _stack.add(prop);\n value = value(_context, _subProxy || receiver);\n _stack.delete(prop);\n if (needsSubResolver(prop, value)) {\n value = createSubResolver(_proxy._scopes, _proxy, prop, value);\n }\n return value;\n}\nfunction _resolveArray(prop, value, target, isIndexable) {\n const {_proxy, _context, _subProxy, _descriptors: descriptors} = target;\n if (defined(_context.index) && isIndexable(prop)) {\n value = value[_context.index % value.length];\n } else if (isObject(value[0])) {\n const arr = value;\n const scopes = _proxy._scopes.filter(s => s !== arr);\n value = [];\n for (const item of arr) {\n const resolver = createSubResolver(scopes, _proxy, prop, item);\n value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors));\n }\n }\n return value;\n}\nfunction resolveFallback(fallback, prop, value) {\n return isFunction(fallback) ? fallback(prop, value) : fallback;\n}\nconst getScope = (key, parent) => key === true ? parent\n : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined;\nfunction addScopes(set, parentScopes, key, parentFallback, value) {\n for (const parent of parentScopes) {\n const scope = getScope(key, parent);\n if (scope) {\n set.add(scope);\n const fallback = resolveFallback(scope._fallback, key, value);\n if (defined(fallback) && fallback !== key && fallback !== parentFallback) {\n return fallback;\n }\n } else if (scope === false && defined(parentFallback) && key !== parentFallback) {\n return null;\n }\n }\n return false;\n}\nfunction createSubResolver(parentScopes, resolver, prop, value) {\n const rootScopes = resolver._rootScopes;\n const fallback = resolveFallback(resolver._fallback, prop, value);\n const allScopes = [...parentScopes, ...rootScopes];\n const set = new Set();\n set.add(value);\n let key = addScopesFromKey(set, allScopes, prop, fallback || prop, value);\n if (key === null) {\n return false;\n }\n if (defined(fallback) && fallback !== prop) {\n key = addScopesFromKey(set, allScopes, fallback, key, value);\n if (key === null) {\n return false;\n }\n }\n return _createResolver(Array.from(set), [''], rootScopes, fallback,\n () => subGetTarget(resolver, prop, value));\n}\nfunction addScopesFromKey(set, allScopes, key, fallback, item) {\n while (key) {\n key = addScopes(set, allScopes, key, fallback, item);\n }\n return key;\n}\nfunction subGetTarget(resolver, prop, value) {\n const parent = resolver._getTarget();\n if (!(prop in parent)) {\n parent[prop] = {};\n }\n const target = parent[prop];\n if (isArray(target) && isObject(value)) {\n return value;\n }\n return target;\n}\nfunction _resolveWithPrefixes(prop, prefixes, scopes, proxy) {\n let value;\n for (const prefix of prefixes) {\n value = _resolve(readKey(prefix, prop), scopes);\n if (defined(value)) {\n return needsSubResolver(prop, value)\n ? createSubResolver(scopes, proxy, prop, value)\n : value;\n }\n }\n}\nfunction _resolve(key, scopes) {\n for (const scope of scopes) {\n if (!scope) {\n continue;\n }\n const value = scope[key];\n if (defined(value)) {\n return value;\n }\n }\n}\nfunction getKeysFromAllScopes(target) {\n let keys = target._keys;\n if (!keys) {\n keys = target._keys = resolveKeysFromAllScopes(target._scopes);\n }\n return keys;\n}\nfunction resolveKeysFromAllScopes(scopes) {\n const set = new Set();\n for (const scope of scopes) {\n for (const key of Object.keys(scope).filter(k => !k.startsWith('_'))) {\n set.add(key);\n }\n }\n return Array.from(set);\n}\nfunction _parseObjectDataRadialScale(meta, data, start, count) {\n const {iScale} = meta;\n const {key = 'r'} = this._parsing;\n const parsed = new Array(count);\n let i, ilen, index, item;\n for (i = 0, ilen = count; i < ilen; ++i) {\n index = i + start;\n item = data[index];\n parsed[i] = {\n r: iScale.parse(resolveObjectKey(item, key), index)\n };\n }\n return parsed;\n}\n\nconst EPSILON = Number.EPSILON || 1e-14;\nconst getPoint = (points, i) => i < points.length && !points[i].skip && points[i];\nconst getValueAxis = (indexAxis) => indexAxis === 'x' ? 'y' : 'x';\nfunction splineCurve(firstPoint, middlePoint, afterPoint, t) {\n const previous = firstPoint.skip ? middlePoint : firstPoint;\n const current = middlePoint;\n const next = afterPoint.skip ? middlePoint : afterPoint;\n const d01 = distanceBetweenPoints(current, previous);\n const d12 = distanceBetweenPoints(next, current);\n let s01 = d01 / (d01 + d12);\n let s12 = d12 / (d01 + d12);\n s01 = isNaN(s01) ? 0 : s01;\n s12 = isNaN(s12) ? 0 : s12;\n const fa = t * s01;\n const fb = t * s12;\n return {\n previous: {\n x: current.x - fa * (next.x - previous.x),\n y: current.y - fa * (next.y - previous.y)\n },\n next: {\n x: current.x + fb * (next.x - previous.x),\n y: current.y + fb * (next.y - previous.y)\n }\n };\n}\nfunction monotoneAdjust(points, deltaK, mK) {\n const pointsLen = points.length;\n let alphaK, betaK, tauK, squaredMagnitude, pointCurrent;\n let pointAfter = getPoint(points, 0);\n for (let i = 0; i < pointsLen - 1; ++i) {\n pointCurrent = pointAfter;\n pointAfter = getPoint(points, i + 1);\n if (!pointCurrent || !pointAfter) {\n continue;\n }\n if (almostEquals(deltaK[i], 0, EPSILON)) {\n mK[i] = mK[i + 1] = 0;\n continue;\n }\n alphaK = mK[i] / deltaK[i];\n betaK = mK[i + 1] / deltaK[i];\n squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);\n if (squaredMagnitude <= 9) {\n continue;\n }\n tauK = 3 / Math.sqrt(squaredMagnitude);\n mK[i] = alphaK * tauK * deltaK[i];\n mK[i + 1] = betaK * tauK * deltaK[i];\n }\n}\nfunction monotoneCompute(points, mK, indexAxis = 'x') {\n const valueAxis = getValueAxis(indexAxis);\n const pointsLen = points.length;\n let delta, pointBefore, pointCurrent;\n let pointAfter = getPoint(points, 0);\n for (let i = 0; i < pointsLen; ++i) {\n pointBefore = pointCurrent;\n pointCurrent = pointAfter;\n pointAfter = getPoint(points, i + 1);\n if (!pointCurrent) {\n continue;\n }\n const iPixel = pointCurrent[indexAxis];\n const vPixel = pointCurrent[valueAxis];\n if (pointBefore) {\n delta = (iPixel - pointBefore[indexAxis]) / 3;\n pointCurrent[`cp1${indexAxis}`] = iPixel - delta;\n pointCurrent[`cp1${valueAxis}`] = vPixel - delta * mK[i];\n }\n if (pointAfter) {\n delta = (pointAfter[indexAxis] - iPixel) / 3;\n pointCurrent[`cp2${indexAxis}`] = iPixel + delta;\n pointCurrent[`cp2${valueAxis}`] = vPixel + delta * mK[i];\n }\n }\n}\nfunction splineCurveMonotone(points, indexAxis = 'x') {\n const valueAxis = getValueAxis(indexAxis);\n const pointsLen = points.length;\n const deltaK = Array(pointsLen).fill(0);\n const mK = Array(pointsLen);\n let i, pointBefore, pointCurrent;\n let pointAfter = getPoint(points, 0);\n for (i = 0; i < pointsLen; ++i) {\n pointBefore = pointCurrent;\n pointCurrent = pointAfter;\n pointAfter = getPoint(points, i + 1);\n if (!pointCurrent) {\n continue;\n }\n if (pointAfter) {\n const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis];\n deltaK[i] = slopeDelta !== 0 ? (pointAfter[valueAxis] - pointCurrent[valueAxis]) / slopeDelta : 0;\n }\n mK[i] = !pointBefore ? deltaK[i]\n : !pointAfter ? deltaK[i - 1]\n : (sign(deltaK[i - 1]) !== sign(deltaK[i])) ? 0\n : (deltaK[i - 1] + deltaK[i]) / 2;\n }\n monotoneAdjust(points, deltaK, mK);\n monotoneCompute(points, mK, indexAxis);\n}\nfunction capControlPoint(pt, min, max) {\n return Math.max(Math.min(pt, max), min);\n}\nfunction capBezierPoints(points, area) {\n let i, ilen, point, inArea, inAreaPrev;\n let inAreaNext = _isPointInArea(points[0], area);\n for (i = 0, ilen = points.length; i < ilen; ++i) {\n inAreaPrev = inArea;\n inArea = inAreaNext;\n inAreaNext = i < ilen - 1 && _isPointInArea(points[i + 1], area);\n if (!inArea) {\n continue;\n }\n point = points[i];\n if (inAreaPrev) {\n point.cp1x = capControlPoint(point.cp1x, area.left, area.right);\n point.cp1y = capControlPoint(point.cp1y, area.top, area.bottom);\n }\n if (inAreaNext) {\n point.cp2x = capControlPoint(point.cp2x, area.left, area.right);\n point.cp2y = capControlPoint(point.cp2y, area.top, area.bottom);\n }\n }\n}\nfunction _updateBezierControlPoints(points, options, area, loop, indexAxis) {\n let i, ilen, point, controlPoints;\n if (options.spanGaps) {\n points = points.filter((pt) => !pt.skip);\n }\n if (options.cubicInterpolationMode === 'monotone') {\n splineCurveMonotone(points, indexAxis);\n } else {\n let prev = loop ? points[points.length - 1] : points[0];\n for (i = 0, ilen = points.length; i < ilen; ++i) {\n point = points[i];\n controlPoints = splineCurve(\n prev,\n point,\n points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen],\n options.tension\n );\n point.cp1x = controlPoints.previous.x;\n point.cp1y = controlPoints.previous.y;\n point.cp2x = controlPoints.next.x;\n point.cp2y = controlPoints.next.y;\n prev = point;\n }\n }\n if (options.capBezierPoints) {\n capBezierPoints(points, area);\n }\n}\n\nfunction _isDomSupported() {\n return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\nfunction _getParentNode(domNode) {\n let parent = domNode.parentNode;\n if (parent && parent.toString() === '[object ShadowRoot]') {\n parent = parent.host;\n }\n return parent;\n}\nfunction parseMaxStyle(styleValue, node, parentProperty) {\n let valueInPixels;\n if (typeof styleValue === 'string') {\n valueInPixels = parseInt(styleValue, 10);\n if (styleValue.indexOf('%') !== -1) {\n valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];\n }\n } else {\n valueInPixels = styleValue;\n }\n return valueInPixels;\n}\nconst getComputedStyle = (element) => window.getComputedStyle(element, null);\nfunction getStyle(el, property) {\n return getComputedStyle(el).getPropertyValue(property);\n}\nconst positions = ['top', 'right', 'bottom', 'left'];\nfunction getPositionedStyle(styles, style, suffix) {\n const result = {};\n suffix = suffix ? '-' + suffix : '';\n for (let i = 0; i < 4; i++) {\n const pos = positions[i];\n result[pos] = parseFloat(styles[style + '-' + pos + suffix]) || 0;\n }\n result.width = result.left + result.right;\n result.height = result.top + result.bottom;\n return result;\n}\nconst useOffsetPos = (x, y, target) => (x > 0 || y > 0) && (!target || !target.shadowRoot);\nfunction getCanvasPosition(e, canvas) {\n const touches = e.touches;\n const source = touches && touches.length ? touches[0] : e;\n const {offsetX, offsetY} = source;\n let box = false;\n let x, y;\n if (useOffsetPos(offsetX, offsetY, e.target)) {\n x = offsetX;\n y = offsetY;\n } else {\n const rect = canvas.getBoundingClientRect();\n x = source.clientX - rect.left;\n y = source.clientY - rect.top;\n box = true;\n }\n return {x, y, box};\n}\nfunction getRelativePosition(evt, chart) {\n if ('native' in evt) {\n return evt;\n }\n const {canvas, currentDevicePixelRatio} = chart;\n const style = getComputedStyle(canvas);\n const borderBox = style.boxSizing === 'border-box';\n const paddings = getPositionedStyle(style, 'padding');\n const borders = getPositionedStyle(style, 'border', 'width');\n const {x, y, box} = getCanvasPosition(evt, canvas);\n const xOffset = paddings.left + (box && borders.left);\n const yOffset = paddings.top + (box && borders.top);\n let {width, height} = chart;\n if (borderBox) {\n width -= paddings.width + borders.width;\n height -= paddings.height + borders.height;\n }\n return {\n x: Math.round((x - xOffset) / width * canvas.width / currentDevicePixelRatio),\n y: Math.round((y - yOffset) / height * canvas.height / currentDevicePixelRatio)\n };\n}\nfunction getContainerSize(canvas, width, height) {\n let maxWidth, maxHeight;\n if (width === undefined || height === undefined) {\n const container = _getParentNode(canvas);\n if (!container) {\n width = canvas.clientWidth;\n height = canvas.clientHeight;\n } else {\n const rect = container.getBoundingClientRect();\n const containerStyle = getComputedStyle(container);\n const containerBorder = getPositionedStyle(containerStyle, 'border', 'width');\n const containerPadding = getPositionedStyle(containerStyle, 'padding');\n width = rect.width - containerPadding.width - containerBorder.width;\n height = rect.height - containerPadding.height - containerBorder.height;\n maxWidth = parseMaxStyle(containerStyle.maxWidth, container, 'clientWidth');\n maxHeight = parseMaxStyle(containerStyle.maxHeight, container, 'clientHeight');\n }\n }\n return {\n width,\n height,\n maxWidth: maxWidth || INFINITY,\n maxHeight: maxHeight || INFINITY\n };\n}\nconst round1 = v => Math.round(v * 10) / 10;\nfunction getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) {\n const style = getComputedStyle(canvas);\n const margins = getPositionedStyle(style, 'margin');\n const maxWidth = parseMaxStyle(style.maxWidth, canvas, 'clientWidth') || INFINITY;\n const maxHeight = parseMaxStyle(style.maxHeight, canvas, 'clientHeight') || INFINITY;\n const containerSize = getContainerSize(canvas, bbWidth, bbHeight);\n let {width, height} = containerSize;\n if (style.boxSizing === 'content-box') {\n const borders = getPositionedStyle(style, 'border', 'width');\n const paddings = getPositionedStyle(style, 'padding');\n width -= paddings.width + borders.width;\n height -= paddings.height + borders.height;\n }\n width = Math.max(0, width - margins.width);\n height = Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height - margins.height);\n width = round1(Math.min(width, maxWidth, containerSize.maxWidth));\n height = round1(Math.min(height, maxHeight, containerSize.maxHeight));\n if (width && !height) {\n height = round1(width / 2);\n }\n return {\n width,\n height\n };\n}\nfunction retinaScale(chart, forceRatio, forceStyle) {\n const pixelRatio = forceRatio || 1;\n const deviceHeight = Math.floor(chart.height * pixelRatio);\n const deviceWidth = Math.floor(chart.width * pixelRatio);\n chart.height = deviceHeight / pixelRatio;\n chart.width = deviceWidth / pixelRatio;\n const canvas = chart.canvas;\n if (canvas.style && (forceStyle || (!canvas.style.height && !canvas.style.width))) {\n canvas.style.height = `${chart.height}px`;\n canvas.style.width = `${chart.width}px`;\n }\n if (chart.currentDevicePixelRatio !== pixelRatio\n || canvas.height !== deviceHeight\n || canvas.width !== deviceWidth) {\n chart.currentDevicePixelRatio = pixelRatio;\n canvas.height = deviceHeight;\n canvas.width = deviceWidth;\n chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);\n return true;\n }\n return false;\n}\nconst supportsEventListenerOptions = (function() {\n let passiveSupported = false;\n try {\n const options = {\n get passive() {\n passiveSupported = true;\n return false;\n }\n };\n window.addEventListener('test', null, options);\n window.removeEventListener('test', null, options);\n } catch (e) {\n }\n return passiveSupported;\n}());\nfunction readUsedSize(element, property) {\n const value = getStyle(element, property);\n const matches = value && value.match(/^(\\d+)(\\.\\d+)?px$/);\n return matches ? +matches[1] : undefined;\n}\n\nfunction _pointInLine(p1, p2, t, mode) {\n return {\n x: p1.x + t * (p2.x - p1.x),\n y: p1.y + t * (p2.y - p1.y)\n };\n}\nfunction _steppedInterpolation(p1, p2, t, mode) {\n return {\n x: p1.x + t * (p2.x - p1.x),\n y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y\n : mode === 'after' ? t < 1 ? p1.y : p2.y\n : t > 0 ? p2.y : p1.y\n };\n}\nfunction _bezierInterpolation(p1, p2, t, mode) {\n const cp1 = {x: p1.cp2x, y: p1.cp2y};\n const cp2 = {x: p2.cp1x, y: p2.cp1y};\n const a = _pointInLine(p1, cp1, t);\n const b = _pointInLine(cp1, cp2, t);\n const c = _pointInLine(cp2, p2, t);\n const d = _pointInLine(a, b, t);\n const e = _pointInLine(b, c, t);\n return _pointInLine(d, e, t);\n}\n\nconst intlCache = new Map();\nfunction getNumberFormat(locale, options) {\n options = options || {};\n const cacheKey = locale + JSON.stringify(options);\n let formatter = intlCache.get(cacheKey);\n if (!formatter) {\n formatter = new Intl.NumberFormat(locale, options);\n intlCache.set(cacheKey, formatter);\n }\n return formatter;\n}\nfunction formatNumber(num, locale, options) {\n return getNumberFormat(locale, options).format(num);\n}\n\nconst getRightToLeftAdapter = function(rectX, width) {\n return {\n x(x) {\n return rectX + rectX + width - x;\n },\n setWidth(w) {\n width = w;\n },\n textAlign(align) {\n if (align === 'center') {\n return align;\n }\n return align === 'right' ? 'left' : 'right';\n },\n xPlus(x, value) {\n return x - value;\n },\n leftForLtr(x, itemWidth) {\n return x - itemWidth;\n },\n };\n};\nconst getLeftToRightAdapter = function() {\n return {\n x(x) {\n return x;\n },\n setWidth(w) {\n },\n textAlign(align) {\n return align;\n },\n xPlus(x, value) {\n return x + value;\n },\n leftForLtr(x, _itemWidth) {\n return x;\n },\n };\n};\nfunction getRtlAdapter(rtl, rectX, width) {\n return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();\n}\nfunction overrideTextDirection(ctx, direction) {\n let style, original;\n if (direction === 'ltr' || direction === 'rtl') {\n style = ctx.canvas.style;\n original = [\n style.getPropertyValue('direction'),\n style.getPropertyPriority('direction'),\n ];\n style.setProperty('direction', direction, 'important');\n ctx.prevTextDirection = original;\n }\n}\nfunction restoreTextDirection(ctx, original) {\n if (original !== undefined) {\n delete ctx.prevTextDirection;\n ctx.canvas.style.setProperty('direction', original[0], original[1]);\n }\n}\n\nfunction propertyFn(property) {\n if (property === 'angle') {\n return {\n between: _angleBetween,\n compare: _angleDiff,\n normalize: _normalizeAngle,\n };\n }\n return {\n between: _isBetween,\n compare: (a, b) => a - b,\n normalize: x => x\n };\n}\nfunction normalizeSegment({start, end, count, loop, style}) {\n return {\n start: start % count,\n end: end % count,\n loop: loop && (end - start + 1) % count === 0,\n style\n };\n}\nfunction getSegment(segment, points, bounds) {\n const {property, start: startBound, end: endBound} = bounds;\n const {between, normalize} = propertyFn(property);\n const count = points.length;\n let {start, end, loop} = segment;\n let i, ilen;\n if (loop) {\n start += count;\n end += count;\n for (i = 0, ilen = count; i < ilen; ++i) {\n if (!between(normalize(points[start % count][property]), startBound, endBound)) {\n break;\n }\n start--;\n end--;\n }\n start %= count;\n end %= count;\n }\n if (end < start) {\n end += count;\n }\n return {start, end, loop, style: segment.style};\n}\nfunction _boundSegment(segment, points, bounds) {\n if (!bounds) {\n return [segment];\n }\n const {property, start: startBound, end: endBound} = bounds;\n const count = points.length;\n const {compare, between, normalize} = propertyFn(property);\n const {start, end, loop, style} = getSegment(segment, points, bounds);\n const result = [];\n let inside = false;\n let subStart = null;\n let value, point, prevValue;\n const startIsBefore = () => between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0;\n const endIsBefore = () => compare(endBound, value) === 0 || between(endBound, prevValue, value);\n const shouldStart = () => inside || startIsBefore();\n const shouldStop = () => !inside || endIsBefore();\n for (let i = start, prev = start; i <= end; ++i) {\n point = points[i % count];\n if (point.skip) {\n continue;\n }\n value = normalize(point[property]);\n if (value === prevValue) {\n continue;\n }\n inside = between(value, startBound, endBound);\n if (subStart === null && shouldStart()) {\n subStart = compare(value, startBound) === 0 ? i : prev;\n }\n if (subStart !== null && shouldStop()) {\n result.push(normalizeSegment({start: subStart, end: i, loop, count, style}));\n subStart = null;\n }\n prev = i;\n prevValue = value;\n }\n if (subStart !== null) {\n result.push(normalizeSegment({start: subStart, end, loop, count, style}));\n }\n return result;\n}\nfunction _boundSegments(line, bounds) {\n const result = [];\n const segments = line.segments;\n for (let i = 0; i < segments.length; i++) {\n const sub = _boundSegment(segments[i], line.points, bounds);\n if (sub.length) {\n result.push(...sub);\n }\n }\n return result;\n}\nfunction findStartAndEnd(points, count, loop, spanGaps) {\n let start = 0;\n let end = count - 1;\n if (loop && !spanGaps) {\n while (start < count && !points[start].skip) {\n start++;\n }\n }\n while (start < count && points[start].skip) {\n start++;\n }\n start %= count;\n if (loop) {\n end += start;\n }\n while (end > start && points[end % count].skip) {\n end--;\n }\n end %= count;\n return {start, end};\n}\nfunction solidSegments(points, start, max, loop) {\n const count = points.length;\n const result = [];\n let last = start;\n let prev = points[start];\n let end;\n for (end = start + 1; end <= max; ++end) {\n const cur = points[end % count];\n if (cur.skip || cur.stop) {\n if (!prev.skip) {\n loop = false;\n result.push({start: start % count, end: (end - 1) % count, loop});\n start = last = cur.stop ? end : null;\n }\n } else {\n last = end;\n if (prev.skip) {\n start = end;\n }\n }\n prev = cur;\n }\n if (last !== null) {\n result.push({start: start % count, end: last % count, loop});\n }\n return result;\n}\nfunction _computeSegments(line, segmentOptions) {\n const points = line.points;\n const spanGaps = line.options.spanGaps;\n const count = points.length;\n if (!count) {\n return [];\n }\n const loop = !!line._loop;\n const {start, end} = findStartAndEnd(points, count, loop, spanGaps);\n if (spanGaps === true) {\n return splitByStyles(line, [{start, end, loop}], points, segmentOptions);\n }\n const max = end < start ? end + count : end;\n const completeLoop = !!line._fullLoop && start === 0 && end === count - 1;\n return splitByStyles(line, solidSegments(points, start, max, completeLoop), points, segmentOptions);\n}\nfunction splitByStyles(line, segments, points, segmentOptions) {\n if (!segmentOptions || !segmentOptions.setContext || !points) {\n return segments;\n }\n return doSplitByStyles(line, segments, points, segmentOptions);\n}\nfunction doSplitByStyles(line, segments, points, segmentOptions) {\n const chartContext = line._chart.getContext();\n const baseStyle = readStyle(line.options);\n const {_datasetIndex: datasetIndex, options: {spanGaps}} = line;\n const count = points.length;\n const result = [];\n let prevStyle = baseStyle;\n let start = segments[0].start;\n let i = start;\n function addStyle(s, e, l, st) {\n const dir = spanGaps ? -1 : 1;\n if (s === e) {\n return;\n }\n s += count;\n while (points[s % count].skip) {\n s -= dir;\n }\n while (points[e % count].skip) {\n e += dir;\n }\n if (s % count !== e % count) {\n result.push({start: s % count, end: e % count, loop: l, style: st});\n prevStyle = st;\n start = e % count;\n }\n }\n for (const segment of segments) {\n start = spanGaps ? start : segment.start;\n let prev = points[start % count];\n let style;\n for (i = start + 1; i <= segment.end; i++) {\n const pt = points[i % count];\n style = readStyle(segmentOptions.setContext(createContext(chartContext, {\n type: 'segment',\n p0: prev,\n p1: pt,\n p0DataIndex: (i - 1) % count,\n p1DataIndex: i % count,\n datasetIndex\n })));\n if (styleChanged(style, prevStyle)) {\n addStyle(start, i - 1, segment.loop, prevStyle);\n }\n prev = pt;\n prevStyle = style;\n }\n if (start < i - 1) {\n addStyle(start, i - 1, segment.loop, prevStyle);\n }\n }\n return result;\n}\nfunction readStyle(options) {\n return {\n backgroundColor: options.backgroundColor,\n borderCapStyle: options.borderCapStyle,\n borderDash: options.borderDash,\n borderDashOffset: options.borderDashOffset,\n borderJoinStyle: options.borderJoinStyle,\n borderWidth: options.borderWidth,\n borderColor: options.borderColor\n };\n}\nfunction styleChanged(style, prevStyle) {\n return prevStyle && JSON.stringify(style) !== JSON.stringify(prevStyle);\n}\n\nexport { toFont as $, _rlookupByKey as A, _isPointInArea as B, getAngleFromPoint as C, toPadding as D, each as E, getMaximumSize as F, _getParentNode as G, HALF_PI as H, readUsedSize as I, throttled as J, supportsEventListenerOptions as K, _isDomSupported as L, log10 as M, _factorize as N, finiteOrDefault as O, PI as P, callback as Q, _addGrace as R, toDegrees as S, TAU as T, _measureText as U, _int16Range as V, _alignPixel as W, clipArea as X, renderText as Y, unclipArea as Z, _arrayUnique as _, resolve as a, QUARTER_PI as a$, _toLeftRightCenter as a0, _alignStartEnd as a1, overrides as a2, merge as a3, _capitalize as a4, descriptors as a5, isFunction as a6, _attachContext as a7, _createResolver as a8, _descriptors as a9, _textX as aA, restoreTextDirection as aB, noop as aC, distanceBetweenPoints as aD, _setMinAndMaxByKey as aE, niceNum as aF, almostWhole as aG, almostEquals as aH, _decimalPlaces as aI, _longestText as aJ, _filterBetween as aK, _lookup as aL, isPatternOrGradient as aM, getHoverColor as aN, clone$1 as aO, _merger as aP, _mergerIf as aQ, _deprecated as aR, toFontString as aS, splineCurve as aT, splineCurveMonotone as aU, getStyle as aV, fontString as aW, toLineHeight as aX, PITAU as aY, INFINITY as aZ, RAD_PER_DEG as a_, mergeIf as aa, uid as ab, debounce as ac, retinaScale as ad, clearCanvas as ae, setsEqual as af, _elementsEqual as ag, _isClickEvent as ah, _isBetween as ai, _readValueToProps as aj, _updateBezierControlPoints as ak, _computeSegments as al, _boundSegments as am, _steppedInterpolation as an, _bezierInterpolation as ao, _pointInLine as ap, _steppedLineTo as aq, _bezierCurveTo as ar, drawPoint as as, addRoundedRectPath as at, toTRBL as au, toTRBLCorners as av, _boundSegment as aw, _normalizeAngle as ax, getRtlAdapter as ay, overrideTextDirection as az, isArray as b, TWO_THIRDS_PI as b0, _angleDiff as b1, color as c, defaults as d, effects as e, resolveObjectKey as f, isNumberFinite as g, createContext as h, isObject as i, defined as j, isNullOrUndef as k, listenArrayEvents as l, toPercentage as m, toDimension as n, formatNumber as o, _angleBetween as p, isNumber as q, requestAnimFrame as r, sign as s, toRadians as t, unlistenArrayEvents as u, valueOrDefault as v, _limitValue as w, _lookupByKey as x, _parseObjectDataRadialScale as y, getRelativePosition as z };\n","/*!\n * Chart.js v3.8.0\n * https://www.chartjs.org\n * (c) 2022 Chart.js Contributors\n * Released under the MIT License\n */\nimport { r as requestAnimFrame, a as resolve, e as effects, c as color, d as defaults, i as isObject, b as isArray, v as valueOrDefault, u as unlistenArrayEvents, l as listenArrayEvents, f as resolveObjectKey, g as isNumberFinite, h as createContext, j as defined, s as sign, k as isNullOrUndef, _ as _arrayUnique, t as toRadians, m as toPercentage, n as toDimension, T as TAU, o as formatNumber, p as _angleBetween, H as HALF_PI, P as PI, q as isNumber, w as _limitValue, x as _lookupByKey, y as _parseObjectDataRadialScale, z as getRelativePosition, A as _rlookupByKey, B as _isPointInArea, C as getAngleFromPoint, D as toPadding, E as each, F as getMaximumSize, G as _getParentNode, I as readUsedSize, J as throttled, K as supportsEventListenerOptions, L as _isDomSupported, M as log10, N as _factorize, O as finiteOrDefault, Q as callback, R as _addGrace, S as toDegrees, U as _measureText, V as _int16Range, W as _alignPixel, X as clipArea, Y as renderText, Z as unclipArea, $ as toFont, a0 as _toLeftRightCenter, a1 as _alignStartEnd, a2 as overrides, a3 as merge, a4 as _capitalize, a5 as descriptors, a6 as isFunction, a7 as _attachContext, a8 as _createResolver, a9 as _descriptors, aa as mergeIf, ab as uid, ac as debounce, ad as retinaScale, ae as clearCanvas, af as setsEqual, ag as _elementsEqual, ah as _isClickEvent, ai as _isBetween, aj as _readValueToProps, ak as _updateBezierControlPoints, al as _computeSegments, am as _boundSegments, an as _steppedInterpolation, ao as _bezierInterpolation, ap as _pointInLine, aq as _steppedLineTo, ar as _bezierCurveTo, as as drawPoint, at as addRoundedRectPath, au as toTRBL, av as toTRBLCorners, aw as _boundSegment, ax as _normalizeAngle, ay as getRtlAdapter, az as overrideTextDirection, aA as _textX, aB as restoreTextDirection, aC as noop, aD as distanceBetweenPoints, aE as _setMinAndMaxByKey, aF as niceNum, aG as almostWhole, aH as almostEquals, aI as _decimalPlaces, aJ as _longestText, aK as _filterBetween, aL as _lookup } from './chunks/helpers.segment.js';\nexport { d as defaults } from './chunks/helpers.segment.js';\n\nclass Animator {\n constructor() {\n this._request = null;\n this._charts = new Map();\n this._running = false;\n this._lastDate = undefined;\n }\n _notify(chart, anims, date, type) {\n const callbacks = anims.listeners[type];\n const numSteps = anims.duration;\n callbacks.forEach(fn => fn({\n chart,\n initial: anims.initial,\n numSteps,\n currentStep: Math.min(date - anims.start, numSteps)\n }));\n }\n _refresh() {\n if (this._request) {\n return;\n }\n this._running = true;\n this._request = requestAnimFrame.call(window, () => {\n this._update();\n this._request = null;\n if (this._running) {\n this._refresh();\n }\n });\n }\n _update(date = Date.now()) {\n let remaining = 0;\n this._charts.forEach((anims, chart) => {\n if (!anims.running || !anims.items.length) {\n return;\n }\n const items = anims.items;\n let i = items.length - 1;\n let draw = false;\n let item;\n for (; i >= 0; --i) {\n item = items[i];\n if (item._active) {\n if (item._total > anims.duration) {\n anims.duration = item._total;\n }\n item.tick(date);\n draw = true;\n } else {\n items[i] = items[items.length - 1];\n items.pop();\n }\n }\n if (draw) {\n chart.draw();\n this._notify(chart, anims, date, 'progress');\n }\n if (!items.length) {\n anims.running = false;\n this._notify(chart, anims, date, 'complete');\n anims.initial = false;\n }\n remaining += items.length;\n });\n this._lastDate = date;\n if (remaining === 0) {\n this._running = false;\n }\n }\n _getAnims(chart) {\n const charts = this._charts;\n let anims = charts.get(chart);\n if (!anims) {\n anims = {\n running: false,\n initial: true,\n items: [],\n listeners: {\n complete: [],\n progress: []\n }\n };\n charts.set(chart, anims);\n }\n return anims;\n }\n listen(chart, event, cb) {\n this._getAnims(chart).listeners[event].push(cb);\n }\n add(chart, items) {\n if (!items || !items.length) {\n return;\n }\n this._getAnims(chart).items.push(...items);\n }\n has(chart) {\n return this._getAnims(chart).items.length > 0;\n }\n start(chart) {\n const anims = this._charts.get(chart);\n if (!anims) {\n return;\n }\n anims.running = true;\n anims.start = Date.now();\n anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0);\n this._refresh();\n }\n running(chart) {\n if (!this._running) {\n return false;\n }\n const anims = this._charts.get(chart);\n if (!anims || !anims.running || !anims.items.length) {\n return false;\n }\n return true;\n }\n stop(chart) {\n const anims = this._charts.get(chart);\n if (!anims || !anims.items.length) {\n return;\n }\n const items = anims.items;\n let i = items.length - 1;\n for (; i >= 0; --i) {\n items[i].cancel();\n }\n anims.items = [];\n this._notify(chart, anims, Date.now(), 'complete');\n }\n remove(chart) {\n return this._charts.delete(chart);\n }\n}\nvar animator = new Animator();\n\nconst transparent = 'transparent';\nconst interpolators = {\n boolean(from, to, factor) {\n return factor > 0.5 ? to : from;\n },\n color(from, to, factor) {\n const c0 = color(from || transparent);\n const c1 = c0.valid && color(to || transparent);\n return c1 && c1.valid\n ? c1.mix(c0, factor).hexString()\n : to;\n },\n number(from, to, factor) {\n return from + (to - from) * factor;\n }\n};\nclass Animation {\n constructor(cfg, target, prop, to) {\n const currentValue = target[prop];\n to = resolve([cfg.to, to, currentValue, cfg.from]);\n const from = resolve([cfg.from, currentValue, to]);\n this._active = true;\n this._fn = cfg.fn || interpolators[cfg.type || typeof from];\n this._easing = effects[cfg.easing] || effects.linear;\n this._start = Math.floor(Date.now() + (cfg.delay || 0));\n this._duration = this._total = Math.floor(cfg.duration);\n this._loop = !!cfg.loop;\n this._target = target;\n this._prop = prop;\n this._from = from;\n this._to = to;\n this._promises = undefined;\n }\n active() {\n return this._active;\n }\n update(cfg, to, date) {\n if (this._active) {\n this._notify(false);\n const currentValue = this._target[this._prop];\n const elapsed = date - this._start;\n const remain = this._duration - elapsed;\n this._start = date;\n this._duration = Math.floor(Math.max(remain, cfg.duration));\n this._total += elapsed;\n this._loop = !!cfg.loop;\n this._to = resolve([cfg.to, to, currentValue, cfg.from]);\n this._from = resolve([cfg.from, currentValue, to]);\n }\n }\n cancel() {\n if (this._active) {\n this.tick(Date.now());\n this._active = false;\n this._notify(false);\n }\n }\n tick(date) {\n const elapsed = date - this._start;\n const duration = this._duration;\n const prop = this._prop;\n const from = this._from;\n const loop = this._loop;\n const to = this._to;\n let factor;\n this._active = from !== to && (loop || (elapsed < duration));\n if (!this._active) {\n this._target[prop] = to;\n this._notify(true);\n return;\n }\n if (elapsed < 0) {\n this._target[prop] = from;\n return;\n }\n factor = (elapsed / duration) % 2;\n factor = loop && factor > 1 ? 2 - factor : factor;\n factor = this._easing(Math.min(1, Math.max(0, factor)));\n this._target[prop] = this._fn(from, to, factor);\n }\n wait() {\n const promises = this._promises || (this._promises = []);\n return new Promise((res, rej) => {\n promises.push({res, rej});\n });\n }\n _notify(resolved) {\n const method = resolved ? 'res' : 'rej';\n const promises = this._promises || [];\n for (let i = 0; i < promises.length; i++) {\n promises[i][method]();\n }\n }\n}\n\nconst numbers = ['x', 'y', 'borderWidth', 'radius', 'tension'];\nconst colors = ['color', 'borderColor', 'backgroundColor'];\ndefaults.set('animation', {\n delay: undefined,\n duration: 1000,\n easing: 'easeOutQuart',\n fn: undefined,\n from: undefined,\n loop: undefined,\n to: undefined,\n type: undefined,\n});\nconst animationOptions = Object.keys(defaults.animation);\ndefaults.describe('animation', {\n _fallback: false,\n _indexable: false,\n _scriptable: (name) => name !== 'onProgress' && name !== 'onComplete' && name !== 'fn',\n});\ndefaults.set('animations', {\n colors: {\n type: 'color',\n properties: colors\n },\n numbers: {\n type: 'number',\n properties: numbers\n },\n});\ndefaults.describe('animations', {\n _fallback: 'animation',\n});\ndefaults.set('transitions', {\n active: {\n animation: {\n duration: 400\n }\n },\n resize: {\n animation: {\n duration: 0\n }\n },\n show: {\n animations: {\n colors: {\n from: 'transparent'\n },\n visible: {\n type: 'boolean',\n duration: 0\n },\n }\n },\n hide: {\n animations: {\n colors: {\n to: 'transparent'\n },\n visible: {\n type: 'boolean',\n easing: 'linear',\n fn: v => v | 0\n },\n }\n }\n});\nclass Animations {\n constructor(chart, config) {\n this._chart = chart;\n this._properties = new Map();\n this.configure(config);\n }\n configure(config) {\n if (!isObject(config)) {\n return;\n }\n const animatedProps = this._properties;\n Object.getOwnPropertyNames(config).forEach(key => {\n const cfg = config[key];\n if (!isObject(cfg)) {\n return;\n }\n const resolved = {};\n for (const option of animationOptions) {\n resolved[option] = cfg[option];\n }\n (isArray(cfg.properties) && cfg.properties || [key]).forEach((prop) => {\n if (prop === key || !animatedProps.has(prop)) {\n animatedProps.set(prop, resolved);\n }\n });\n });\n }\n _animateOptions(target, values) {\n const newOptions = values.options;\n const options = resolveTargetOptions(target, newOptions);\n if (!options) {\n return [];\n }\n const animations = this._createAnimations(options, newOptions);\n if (newOptions.$shared) {\n awaitAll(target.options.$animations, newOptions).then(() => {\n target.options = newOptions;\n }, () => {\n });\n }\n return animations;\n }\n _createAnimations(target, values) {\n const animatedProps = this._properties;\n const animations = [];\n const running = target.$animations || (target.$animations = {});\n const props = Object.keys(values);\n const date = Date.now();\n let i;\n for (i = props.length - 1; i >= 0; --i) {\n const prop = props[i];\n if (prop.charAt(0) === '$') {\n continue;\n }\n if (prop === 'options') {\n animations.push(...this._animateOptions(target, values));\n continue;\n }\n const value = values[prop];\n let animation = running[prop];\n const cfg = animatedProps.get(prop);\n if (animation) {\n if (cfg && animation.active()) {\n animation.update(cfg, value, date);\n continue;\n } else {\n animation.cancel();\n }\n }\n if (!cfg || !cfg.duration) {\n target[prop] = value;\n continue;\n }\n running[prop] = animation = new Animation(cfg, target, prop, value);\n animations.push(animation);\n }\n return animations;\n }\n update(target, values) {\n if (this._properties.size === 0) {\n Object.assign(target, values);\n return;\n }\n const animations = this._createAnimations(target, values);\n if (animations.length) {\n animator.add(this._chart, animations);\n return true;\n }\n }\n}\nfunction awaitAll(animations, properties) {\n const running = [];\n const keys = Object.keys(properties);\n for (let i = 0; i < keys.length; i++) {\n const anim = animations[keys[i]];\n if (anim && anim.active()) {\n running.push(anim.wait());\n }\n }\n return Promise.all(running);\n}\nfunction resolveTargetOptions(target, newOptions) {\n if (!newOptions) {\n return;\n }\n let options = target.options;\n if (!options) {\n target.options = newOptions;\n return;\n }\n if (options.$shared) {\n target.options = options = Object.assign({}, options, {$shared: false, $animations: {}});\n }\n return options;\n}\n\nfunction scaleClip(scale, allowedOverflow) {\n const opts = scale && scale.options || {};\n const reverse = opts.reverse;\n const min = opts.min === undefined ? allowedOverflow : 0;\n const max = opts.max === undefined ? allowedOverflow : 0;\n return {\n start: reverse ? max : min,\n end: reverse ? min : max\n };\n}\nfunction defaultClip(xScale, yScale, allowedOverflow) {\n if (allowedOverflow === false) {\n return false;\n }\n const x = scaleClip(xScale, allowedOverflow);\n const y = scaleClip(yScale, allowedOverflow);\n return {\n top: y.end,\n right: x.end,\n bottom: y.start,\n left: x.start\n };\n}\nfunction toClip(value) {\n let t, r, b, l;\n if (isObject(value)) {\n t = value.top;\n r = value.right;\n b = value.bottom;\n l = value.left;\n } else {\n t = r = b = l = value;\n }\n return {\n top: t,\n right: r,\n bottom: b,\n left: l,\n disabled: value === false\n };\n}\nfunction getSortedDatasetIndices(chart, filterVisible) {\n const keys = [];\n const metasets = chart._getSortedDatasetMetas(filterVisible);\n let i, ilen;\n for (i = 0, ilen = metasets.length; i < ilen; ++i) {\n keys.push(metasets[i].index);\n }\n return keys;\n}\nfunction applyStack(stack, value, dsIndex, options = {}) {\n const keys = stack.keys;\n const singleMode = options.mode === 'single';\n let i, ilen, datasetIndex, otherValue;\n if (value === null) {\n return;\n }\n for (i = 0, ilen = keys.length; i < ilen; ++i) {\n datasetIndex = +keys[i];\n if (datasetIndex === dsIndex) {\n if (options.all) {\n continue;\n }\n break;\n }\n otherValue = stack.values[datasetIndex];\n if (isNumberFinite(otherValue) && (singleMode || (value === 0 || sign(value) === sign(otherValue)))) {\n value += otherValue;\n }\n }\n return value;\n}\nfunction convertObjectDataToArray(data) {\n const keys = Object.keys(data);\n const adata = new Array(keys.length);\n let i, ilen, key;\n for (i = 0, ilen = keys.length; i < ilen; ++i) {\n key = keys[i];\n adata[i] = {\n x: key,\n y: data[key]\n };\n }\n return adata;\n}\nfunction isStacked(scale, meta) {\n const stacked = scale && scale.options.stacked;\n return stacked || (stacked === undefined && meta.stack !== undefined);\n}\nfunction getStackKey(indexScale, valueScale, meta) {\n return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;\n}\nfunction getUserBounds(scale) {\n const {min, max, minDefined, maxDefined} = scale.getUserBounds();\n return {\n min: minDefined ? min : Number.NEGATIVE_INFINITY,\n max: maxDefined ? max : Number.POSITIVE_INFINITY\n };\n}\nfunction getOrCreateStack(stacks, stackKey, indexValue) {\n const subStack = stacks[stackKey] || (stacks[stackKey] = {});\n return subStack[indexValue] || (subStack[indexValue] = {});\n}\nfunction getLastIndexInStack(stack, vScale, positive, type) {\n for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) {\n const value = stack[meta.index];\n if ((positive && value > 0) || (!positive && value < 0)) {\n return meta.index;\n }\n }\n return null;\n}\nfunction updateStacks(controller, parsed) {\n const {chart, _cachedMeta: meta} = controller;\n const stacks = chart._stacks || (chart._stacks = {});\n const {iScale, vScale, index: datasetIndex} = meta;\n const iAxis = iScale.axis;\n const vAxis = vScale.axis;\n const key = getStackKey(iScale, vScale, meta);\n const ilen = parsed.length;\n let stack;\n for (let i = 0; i < ilen; ++i) {\n const item = parsed[i];\n const {[iAxis]: index, [vAxis]: value} = item;\n const itemStacks = item._stacks || (item._stacks = {});\n stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);\n stack[datasetIndex] = value;\n stack._top = getLastIndexInStack(stack, vScale, true, meta.type);\n stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);\n }\n}\nfunction getFirstScaleId(chart, axis) {\n const scales = chart.scales;\n return Object.keys(scales).filter(key => scales[key].axis === axis).shift();\n}\nfunction createDatasetContext(parent, index) {\n return createContext(parent,\n {\n active: false,\n dataset: undefined,\n datasetIndex: index,\n index,\n mode: 'default',\n type: 'dataset'\n }\n );\n}\nfunction createDataContext(parent, index, element) {\n return createContext(parent, {\n active: false,\n dataIndex: index,\n parsed: undefined,\n raw: undefined,\n element,\n index,\n mode: 'default',\n type: 'data'\n });\n}\nfunction clearStacks(meta, items) {\n const datasetIndex = meta.controller.index;\n const axis = meta.vScale && meta.vScale.axis;\n if (!axis) {\n return;\n }\n items = items || meta._parsed;\n for (const parsed of items) {\n const stacks = parsed._stacks;\n if (!stacks || stacks[axis] === undefined || stacks[axis][datasetIndex] === undefined) {\n return;\n }\n delete stacks[axis][datasetIndex];\n }\n}\nconst isDirectUpdateMode = (mode) => mode === 'reset' || mode === 'none';\nconst cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached);\nconst createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked\n && {keys: getSortedDatasetIndices(chart, true), values: null};\nclass DatasetController {\n constructor(chart, datasetIndex) {\n this.chart = chart;\n this._ctx = chart.ctx;\n this.index = datasetIndex;\n this._cachedDataOpts = {};\n this._cachedMeta = this.getMeta();\n this._type = this._cachedMeta.type;\n this.options = undefined;\n this._parsing = false;\n this._data = undefined;\n this._objectData = undefined;\n this._sharedOptions = undefined;\n this._drawStart = undefined;\n this._drawCount = undefined;\n this.enableOptionSharing = false;\n this.supportsDecimation = false;\n this.$context = undefined;\n this._syncList = [];\n this.initialize();\n }\n initialize() {\n const meta = this._cachedMeta;\n this.configure();\n this.linkScales();\n meta._stacked = isStacked(meta.vScale, meta);\n this.addElements();\n }\n updateIndex(datasetIndex) {\n if (this.index !== datasetIndex) {\n clearStacks(this._cachedMeta);\n }\n this.index = datasetIndex;\n }\n linkScales() {\n const chart = this.chart;\n const meta = this._cachedMeta;\n const dataset = this.getDataset();\n const chooseId = (axis, x, y, r) => axis === 'x' ? x : axis === 'r' ? r : y;\n const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x'));\n const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y'));\n const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r'));\n const indexAxis = meta.indexAxis;\n const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);\n const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);\n meta.xScale = this.getScaleForId(xid);\n meta.yScale = this.getScaleForId(yid);\n meta.rScale = this.getScaleForId(rid);\n meta.iScale = this.getScaleForId(iid);\n meta.vScale = this.getScaleForId(vid);\n }\n getDataset() {\n return this.chart.data.datasets[this.index];\n }\n getMeta() {\n return this.chart.getDatasetMeta(this.index);\n }\n getScaleForId(scaleID) {\n return this.chart.scales[scaleID];\n }\n _getOtherScale(scale) {\n const meta = this._cachedMeta;\n return scale === meta.iScale\n ? meta.vScale\n : meta.iScale;\n }\n reset() {\n this._update('reset');\n }\n _destroy() {\n const meta = this._cachedMeta;\n if (this._data) {\n unlistenArrayEvents(this._data, this);\n }\n if (meta._stacked) {\n clearStacks(meta);\n }\n }\n _dataCheck() {\n const dataset = this.getDataset();\n const data = dataset.data || (dataset.data = []);\n const _data = this._data;\n if (isObject(data)) {\n this._data = convertObjectDataToArray(data);\n } else if (_data !== data) {\n if (_data) {\n unlistenArrayEvents(_data, this);\n const meta = this._cachedMeta;\n clearStacks(meta);\n meta._parsed = [];\n }\n if (data && Object.isExtensible(data)) {\n listenArrayEvents(data, this);\n }\n this._syncList = [];\n this._data = data;\n }\n }\n addElements() {\n const meta = this._cachedMeta;\n this._dataCheck();\n if (this.datasetElementType) {\n meta.dataset = new this.datasetElementType();\n }\n }\n buildOrUpdateElements(resetNewElements) {\n const meta = this._cachedMeta;\n const dataset = this.getDataset();\n let stackChanged = false;\n this._dataCheck();\n const oldStacked = meta._stacked;\n meta._stacked = isStacked(meta.vScale, meta);\n if (meta.stack !== dataset.stack) {\n stackChanged = true;\n clearStacks(meta);\n meta.stack = dataset.stack;\n }\n this._resyncElements(resetNewElements);\n if (stackChanged || oldStacked !== meta._stacked) {\n updateStacks(this, meta._parsed);\n }\n }\n configure() {\n const config = this.chart.config;\n const scopeKeys = config.datasetScopeKeys(this._type);\n const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);\n this.options = config.createResolver(scopes, this.getContext());\n this._parsing = this.options.parsing;\n this._cachedDataOpts = {};\n }\n parse(start, count) {\n const {_cachedMeta: meta, _data: data} = this;\n const {iScale, _stacked} = meta;\n const iAxis = iScale.axis;\n let sorted = start === 0 && count === data.length ? true : meta._sorted;\n let prev = start > 0 && meta._parsed[start - 1];\n let i, cur, parsed;\n if (this._parsing === false) {\n meta._parsed = data;\n meta._sorted = true;\n parsed = data;\n } else {\n if (isArray(data[start])) {\n parsed = this.parseArrayData(meta, data, start, count);\n } else if (isObject(data[start])) {\n parsed = this.parseObjectData(meta, data, start, count);\n } else {\n parsed = this.parsePrimitiveData(meta, data, start, count);\n }\n const isNotInOrderComparedToPrev = () => cur[iAxis] === null || (prev && cur[iAxis] < prev[iAxis]);\n for (i = 0; i < count; ++i) {\n meta._parsed[i + start] = cur = parsed[i];\n if (sorted) {\n if (isNotInOrderComparedToPrev()) {\n sorted = false;\n }\n prev = cur;\n }\n }\n meta._sorted = sorted;\n }\n if (_stacked) {\n updateStacks(this, parsed);\n }\n }\n parsePrimitiveData(meta, data, start, count) {\n const {iScale, vScale} = meta;\n const iAxis = iScale.axis;\n const vAxis = vScale.axis;\n const labels = iScale.getLabels();\n const singleScale = iScale === vScale;\n const parsed = new Array(count);\n let i, ilen, index;\n for (i = 0, ilen = count; i < ilen; ++i) {\n index = i + start;\n parsed[i] = {\n [iAxis]: singleScale || iScale.parse(labels[index], index),\n [vAxis]: vScale.parse(data[index], index)\n };\n }\n return parsed;\n }\n parseArrayData(meta, data, start, count) {\n const {xScale, yScale} = meta;\n const parsed = new Array(count);\n let i, ilen, index, item;\n for (i = 0, ilen = count; i < ilen; ++i) {\n index = i + start;\n item = data[index];\n parsed[i] = {\n x: xScale.parse(item[0], index),\n y: yScale.parse(item[1], index)\n };\n }\n return parsed;\n }\n parseObjectData(meta, data, start, count) {\n const {xScale, yScale} = meta;\n const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;\n const parsed = new Array(count);\n let i, ilen, index, item;\n for (i = 0, ilen = count; i < ilen; ++i) {\n index = i + start;\n item = data[index];\n parsed[i] = {\n x: xScale.parse(resolveObjectKey(item, xAxisKey), index),\n y: yScale.parse(resolveObjectKey(item, yAxisKey), index)\n };\n }\n return parsed;\n }\n getParsed(index) {\n return this._cachedMeta._parsed[index];\n }\n getDataElement(index) {\n return this._cachedMeta.data[index];\n }\n applyStack(scale, parsed, mode) {\n const chart = this.chart;\n const meta = this._cachedMeta;\n const value = parsed[scale.axis];\n const stack = {\n keys: getSortedDatasetIndices(chart, true),\n values: parsed._stacks[scale.axis]\n };\n return applyStack(stack, value, meta.index, {mode});\n }\n updateRangeFromParsed(range, scale, parsed, stack) {\n const parsedValue = parsed[scale.axis];\n let value = parsedValue === null ? NaN : parsedValue;\n const values = stack && parsed._stacks[scale.axis];\n if (stack && values) {\n stack.values = values;\n value = applyStack(stack, parsedValue, this._cachedMeta.index);\n }\n range.min = Math.min(range.min, value);\n range.max = Math.max(range.max, value);\n }\n getMinMax(scale, canStack) {\n const meta = this._cachedMeta;\n const _parsed = meta._parsed;\n const sorted = meta._sorted && scale === meta.iScale;\n const ilen = _parsed.length;\n const otherScale = this._getOtherScale(scale);\n const stack = createStack(canStack, meta, this.chart);\n const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY};\n const {min: otherMin, max: otherMax} = getUserBounds(otherScale);\n let i, parsed;\n function _skip() {\n parsed = _parsed[i];\n const otherValue = parsed[otherScale.axis];\n return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;\n }\n for (i = 0; i < ilen; ++i) {\n if (_skip()) {\n continue;\n }\n this.updateRangeFromParsed(range, scale, parsed, stack);\n if (sorted) {\n break;\n }\n }\n if (sorted) {\n for (i = ilen - 1; i >= 0; --i) {\n if (_skip()) {\n continue;\n }\n this.updateRangeFromParsed(range, scale, parsed, stack);\n break;\n }\n }\n return range;\n }\n getAllParsedValues(scale) {\n const parsed = this._cachedMeta._parsed;\n const values = [];\n let i, ilen, value;\n for (i = 0, ilen = parsed.length; i < ilen; ++i) {\n value = parsed[i][scale.axis];\n if (isNumberFinite(value)) {\n values.push(value);\n }\n }\n return values;\n }\n getMaxOverflow() {\n return false;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const iScale = meta.iScale;\n const vScale = meta.vScale;\n const parsed = this.getParsed(index);\n return {\n label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '',\n value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : ''\n };\n }\n _update(mode) {\n const meta = this._cachedMeta;\n this.update(mode || 'default');\n meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));\n }\n update(mode) {}\n draw() {\n const ctx = this._ctx;\n const chart = this.chart;\n const meta = this._cachedMeta;\n const elements = meta.data || [];\n const area = chart.chartArea;\n const active = [];\n const start = this._drawStart || 0;\n const count = this._drawCount || (elements.length - start);\n const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;\n let i;\n if (meta.dataset) {\n meta.dataset.draw(ctx, area, start, count);\n }\n for (i = start; i < start + count; ++i) {\n const element = elements[i];\n if (element.hidden) {\n continue;\n }\n if (element.active && drawActiveElementsOnTop) {\n active.push(element);\n } else {\n element.draw(ctx, area);\n }\n }\n for (i = 0; i < active.length; ++i) {\n active[i].draw(ctx, area);\n }\n }\n getStyle(index, active) {\n const mode = active ? 'active' : 'default';\n return index === undefined && this._cachedMeta.dataset\n ? this.resolveDatasetElementOptions(mode)\n : this.resolveDataElementOptions(index || 0, mode);\n }\n getContext(index, active, mode) {\n const dataset = this.getDataset();\n let context;\n if (index >= 0 && index < this._cachedMeta.data.length) {\n const element = this._cachedMeta.data[index];\n context = element.$context ||\n (element.$context = createDataContext(this.getContext(), index, element));\n context.parsed = this.getParsed(index);\n context.raw = dataset.data[index];\n context.index = context.dataIndex = index;\n } else {\n context = this.$context ||\n (this.$context = createDatasetContext(this.chart.getContext(), this.index));\n context.dataset = dataset;\n context.index = context.datasetIndex = this.index;\n }\n context.active = !!active;\n context.mode = mode;\n return context;\n }\n resolveDatasetElementOptions(mode) {\n return this._resolveElementOptions(this.datasetElementType.id, mode);\n }\n resolveDataElementOptions(index, mode) {\n return this._resolveElementOptions(this.dataElementType.id, mode, index);\n }\n _resolveElementOptions(elementType, mode = 'default', index) {\n const active = mode === 'active';\n const cache = this._cachedDataOpts;\n const cacheKey = elementType + '-' + mode;\n const cached = cache[cacheKey];\n const sharing = this.enableOptionSharing && defined(index);\n if (cached) {\n return cloneIfNotShared(cached, sharing);\n }\n const config = this.chart.config;\n const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);\n const prefixes = active ? [`${elementType}Hover`, 'hover', elementType, ''] : [elementType, ''];\n const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);\n const names = Object.keys(defaults.elements[elementType]);\n const context = () => this.getContext(index, active);\n const values = config.resolveNamedOptions(scopes, names, context, prefixes);\n if (values.$shared) {\n values.$shared = sharing;\n cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));\n }\n return values;\n }\n _resolveAnimations(index, transition, active) {\n const chart = this.chart;\n const cache = this._cachedDataOpts;\n const cacheKey = `animation-${transition}`;\n const cached = cache[cacheKey];\n if (cached) {\n return cached;\n }\n let options;\n if (chart.options.animation !== false) {\n const config = this.chart.config;\n const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);\n const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);\n options = config.createResolver(scopes, this.getContext(index, active, transition));\n }\n const animations = new Animations(chart, options && options.animations);\n if (options && options._cacheable) {\n cache[cacheKey] = Object.freeze(animations);\n }\n return animations;\n }\n getSharedOptions(options) {\n if (!options.$shared) {\n return;\n }\n return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));\n }\n includeOptions(mode, sharedOptions) {\n return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;\n }\n updateElement(element, index, properties, mode) {\n if (isDirectUpdateMode(mode)) {\n Object.assign(element, properties);\n } else {\n this._resolveAnimations(index, mode).update(element, properties);\n }\n }\n updateSharedOptions(sharedOptions, mode, newOptions) {\n if (sharedOptions && !isDirectUpdateMode(mode)) {\n this._resolveAnimations(undefined, mode).update(sharedOptions, newOptions);\n }\n }\n _setStyle(element, index, mode, active) {\n element.active = active;\n const options = this.getStyle(index, active);\n this._resolveAnimations(index, mode, active).update(element, {\n options: (!active && this.getSharedOptions(options)) || options\n });\n }\n removeHoverStyle(element, datasetIndex, index) {\n this._setStyle(element, index, 'active', false);\n }\n setHoverStyle(element, datasetIndex, index) {\n this._setStyle(element, index, 'active', true);\n }\n _removeDatasetHoverStyle() {\n const element = this._cachedMeta.dataset;\n if (element) {\n this._setStyle(element, undefined, 'active', false);\n }\n }\n _setDatasetHoverStyle() {\n const element = this._cachedMeta.dataset;\n if (element) {\n this._setStyle(element, undefined, 'active', true);\n }\n }\n _resyncElements(resetNewElements) {\n const data = this._data;\n const elements = this._cachedMeta.data;\n for (const [method, arg1, arg2] of this._syncList) {\n this[method](arg1, arg2);\n }\n this._syncList = [];\n const numMeta = elements.length;\n const numData = data.length;\n const count = Math.min(numData, numMeta);\n if (count) {\n this.parse(0, count);\n }\n if (numData > numMeta) {\n this._insertElements(numMeta, numData - numMeta, resetNewElements);\n } else if (numData < numMeta) {\n this._removeElements(numData, numMeta - numData);\n }\n }\n _insertElements(start, count, resetNewElements = true) {\n const meta = this._cachedMeta;\n const data = meta.data;\n const end = start + count;\n let i;\n const move = (arr) => {\n arr.length += count;\n for (i = arr.length - 1; i >= end; i--) {\n arr[i] = arr[i - count];\n }\n };\n move(data);\n for (i = start; i < end; ++i) {\n data[i] = new this.dataElementType();\n }\n if (this._parsing) {\n move(meta._parsed);\n }\n this.parse(start, count);\n if (resetNewElements) {\n this.updateElements(data, start, count, 'reset');\n }\n }\n updateElements(element, start, count, mode) {}\n _removeElements(start, count) {\n const meta = this._cachedMeta;\n if (this._parsing) {\n const removed = meta._parsed.splice(start, count);\n if (meta._stacked) {\n clearStacks(meta, removed);\n }\n }\n meta.data.splice(start, count);\n }\n _sync(args) {\n if (this._parsing) {\n this._syncList.push(args);\n } else {\n const [method, arg1, arg2] = args;\n this[method](arg1, arg2);\n }\n this.chart._dataChanges.push([this.index, ...args]);\n }\n _onDataPush() {\n const count = arguments.length;\n this._sync(['_insertElements', this.getDataset().data.length - count, count]);\n }\n _onDataPop() {\n this._sync(['_removeElements', this._cachedMeta.data.length - 1, 1]);\n }\n _onDataShift() {\n this._sync(['_removeElements', 0, 1]);\n }\n _onDataSplice(start, count) {\n if (count) {\n this._sync(['_removeElements', start, count]);\n }\n const newCount = arguments.length - 2;\n if (newCount) {\n this._sync(['_insertElements', start, newCount]);\n }\n }\n _onDataUnshift() {\n this._sync(['_insertElements', 0, arguments.length]);\n }\n}\nDatasetController.defaults = {};\nDatasetController.prototype.datasetElementType = null;\nDatasetController.prototype.dataElementType = null;\n\nfunction getAllScaleValues(scale, type) {\n if (!scale._cache.$bar) {\n const visibleMetas = scale.getMatchingVisibleMetas(type);\n let values = [];\n for (let i = 0, ilen = visibleMetas.length; i < ilen; i++) {\n values = values.concat(visibleMetas[i].controller.getAllParsedValues(scale));\n }\n scale._cache.$bar = _arrayUnique(values.sort((a, b) => a - b));\n }\n return scale._cache.$bar;\n}\nfunction computeMinSampleSize(meta) {\n const scale = meta.iScale;\n const values = getAllScaleValues(scale, meta.type);\n let min = scale._length;\n let i, ilen, curr, prev;\n const updateMinAndPrev = () => {\n if (curr === 32767 || curr === -32768) {\n return;\n }\n if (defined(prev)) {\n min = Math.min(min, Math.abs(curr - prev) || min);\n }\n prev = curr;\n };\n for (i = 0, ilen = values.length; i < ilen; ++i) {\n curr = scale.getPixelForValue(values[i]);\n updateMinAndPrev();\n }\n prev = undefined;\n for (i = 0, ilen = scale.ticks.length; i < ilen; ++i) {\n curr = scale.getPixelForTick(i);\n updateMinAndPrev();\n }\n return min;\n}\nfunction computeFitCategoryTraits(index, ruler, options, stackCount) {\n const thickness = options.barThickness;\n let size, ratio;\n if (isNullOrUndef(thickness)) {\n size = ruler.min * options.categoryPercentage;\n ratio = options.barPercentage;\n } else {\n size = thickness * stackCount;\n ratio = 1;\n }\n return {\n chunk: size / stackCount,\n ratio,\n start: ruler.pixels[index] - (size / 2)\n };\n}\nfunction computeFlexCategoryTraits(index, ruler, options, stackCount) {\n const pixels = ruler.pixels;\n const curr = pixels[index];\n let prev = index > 0 ? pixels[index - 1] : null;\n let next = index < pixels.length - 1 ? pixels[index + 1] : null;\n const percent = options.categoryPercentage;\n if (prev === null) {\n prev = curr - (next === null ? ruler.end - ruler.start : next - curr);\n }\n if (next === null) {\n next = curr + curr - prev;\n }\n const start = curr - (curr - Math.min(prev, next)) / 2 * percent;\n const size = Math.abs(next - prev) / 2 * percent;\n return {\n chunk: size / stackCount,\n ratio: options.barPercentage,\n start\n };\n}\nfunction parseFloatBar(entry, item, vScale, i) {\n const startValue = vScale.parse(entry[0], i);\n const endValue = vScale.parse(entry[1], i);\n const min = Math.min(startValue, endValue);\n const max = Math.max(startValue, endValue);\n let barStart = min;\n let barEnd = max;\n if (Math.abs(min) > Math.abs(max)) {\n barStart = max;\n barEnd = min;\n }\n item[vScale.axis] = barEnd;\n item._custom = {\n barStart,\n barEnd,\n start: startValue,\n end: endValue,\n min,\n max\n };\n}\nfunction parseValue(entry, item, vScale, i) {\n if (isArray(entry)) {\n parseFloatBar(entry, item, vScale, i);\n } else {\n item[vScale.axis] = vScale.parse(entry, i);\n }\n return item;\n}\nfunction parseArrayOrPrimitive(meta, data, start, count) {\n const iScale = meta.iScale;\n const vScale = meta.vScale;\n const labels = iScale.getLabels();\n const singleScale = iScale === vScale;\n const parsed = [];\n let i, ilen, item, entry;\n for (i = start, ilen = start + count; i < ilen; ++i) {\n entry = data[i];\n item = {};\n item[iScale.axis] = singleScale || iScale.parse(labels[i], i);\n parsed.push(parseValue(entry, item, vScale, i));\n }\n return parsed;\n}\nfunction isFloatBar(custom) {\n return custom && custom.barStart !== undefined && custom.barEnd !== undefined;\n}\nfunction barSign(size, vScale, actualBase) {\n if (size !== 0) {\n return sign(size);\n }\n return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1);\n}\nfunction borderProps(properties) {\n let reverse, start, end, top, bottom;\n if (properties.horizontal) {\n reverse = properties.base > properties.x;\n start = 'left';\n end = 'right';\n } else {\n reverse = properties.base < properties.y;\n start = 'bottom';\n end = 'top';\n }\n if (reverse) {\n top = 'end';\n bottom = 'start';\n } else {\n top = 'start';\n bottom = 'end';\n }\n return {start, end, reverse, top, bottom};\n}\nfunction setBorderSkipped(properties, options, stack, index) {\n let edge = options.borderSkipped;\n const res = {};\n if (!edge) {\n properties.borderSkipped = res;\n return;\n }\n const {start, end, reverse, top, bottom} = borderProps(properties);\n if (edge === 'middle' && stack) {\n properties.enableBorderRadius = true;\n if ((stack._top || 0) === index) {\n edge = top;\n } else if ((stack._bottom || 0) === index) {\n edge = bottom;\n } else {\n res[parseEdge(bottom, start, end, reverse)] = true;\n edge = top;\n }\n }\n res[parseEdge(edge, start, end, reverse)] = true;\n properties.borderSkipped = res;\n}\nfunction parseEdge(edge, a, b, reverse) {\n if (reverse) {\n edge = swap(edge, a, b);\n edge = startEnd(edge, b, a);\n } else {\n edge = startEnd(edge, a, b);\n }\n return edge;\n}\nfunction swap(orig, v1, v2) {\n return orig === v1 ? v2 : orig === v2 ? v1 : orig;\n}\nfunction startEnd(v, start, end) {\n return v === 'start' ? start : v === 'end' ? end : v;\n}\nfunction setInflateAmount(properties, {inflateAmount}, ratio) {\n properties.inflateAmount = inflateAmount === 'auto'\n ? ratio === 1 ? 0.33 : 0\n : inflateAmount;\n}\nclass BarController extends DatasetController {\n parsePrimitiveData(meta, data, start, count) {\n return parseArrayOrPrimitive(meta, data, start, count);\n }\n parseArrayData(meta, data, start, count) {\n return parseArrayOrPrimitive(meta, data, start, count);\n }\n parseObjectData(meta, data, start, count) {\n const {iScale, vScale} = meta;\n const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;\n const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey;\n const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey;\n const parsed = [];\n let i, ilen, item, obj;\n for (i = start, ilen = start + count; i < ilen; ++i) {\n obj = data[i];\n item = {};\n item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i);\n parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i));\n }\n return parsed;\n }\n updateRangeFromParsed(range, scale, parsed, stack) {\n super.updateRangeFromParsed(range, scale, parsed, stack);\n const custom = parsed._custom;\n if (custom && scale === this._cachedMeta.vScale) {\n range.min = Math.min(range.min, custom.min);\n range.max = Math.max(range.max, custom.max);\n }\n }\n getMaxOverflow() {\n return 0;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const {iScale, vScale} = meta;\n const parsed = this.getParsed(index);\n const custom = parsed._custom;\n const value = isFloatBar(custom)\n ? '[' + custom.start + ', ' + custom.end + ']'\n : '' + vScale.getLabelForValue(parsed[vScale.axis]);\n return {\n label: '' + iScale.getLabelForValue(parsed[iScale.axis]),\n value\n };\n }\n initialize() {\n this.enableOptionSharing = true;\n super.initialize();\n const meta = this._cachedMeta;\n meta.stack = this.getDataset().stack;\n }\n update(mode) {\n const meta = this._cachedMeta;\n this.updateElements(meta.data, 0, meta.data.length, mode);\n }\n updateElements(bars, start, count, mode) {\n const reset = mode === 'reset';\n const {index, _cachedMeta: {vScale}} = this;\n const base = vScale.getBasePixel();\n const horizontal = vScale.isHorizontal();\n const ruler = this._getRuler();\n const firstOpts = this.resolveDataElementOptions(start, mode);\n const sharedOptions = this.getSharedOptions(firstOpts);\n const includeOptions = this.includeOptions(mode, sharedOptions);\n this.updateSharedOptions(sharedOptions, mode, firstOpts);\n for (let i = start; i < start + count; i++) {\n const parsed = this.getParsed(i);\n const vpixels = reset || isNullOrUndef(parsed[vScale.axis]) ? {base, head: base} : this._calculateBarValuePixels(i);\n const ipixels = this._calculateBarIndexPixels(i, ruler);\n const stack = (parsed._stacks || {})[vScale.axis];\n const properties = {\n horizontal,\n base: vpixels.base,\n enableBorderRadius: !stack || isFloatBar(parsed._custom) || (index === stack._top || index === stack._bottom),\n x: horizontal ? vpixels.head : ipixels.center,\n y: horizontal ? ipixels.center : vpixels.head,\n height: horizontal ? ipixels.size : Math.abs(vpixels.size),\n width: horizontal ? Math.abs(vpixels.size) : ipixels.size\n };\n if (includeOptions) {\n properties.options = sharedOptions || this.resolveDataElementOptions(i, bars[i].active ? 'active' : mode);\n }\n const options = properties.options || bars[i].options;\n setBorderSkipped(properties, options, stack, index);\n setInflateAmount(properties, options, ruler.ratio);\n this.updateElement(bars[i], i, properties, mode);\n }\n }\n _getStacks(last, dataIndex) {\n const meta = this._cachedMeta;\n const iScale = meta.iScale;\n const metasets = iScale.getMatchingVisibleMetas(this._type);\n const stacked = iScale.options.stacked;\n const ilen = metasets.length;\n const stacks = [];\n let i, item;\n for (i = 0; i < ilen; ++i) {\n item = metasets[i];\n if (!item.controller.options.grouped) {\n continue;\n }\n if (typeof dataIndex !== 'undefined') {\n const val = item.controller.getParsed(dataIndex)[\n item.controller._cachedMeta.vScale.axis\n ];\n if (isNullOrUndef(val) || isNaN(val)) {\n continue;\n }\n }\n if (stacked === false || stacks.indexOf(item.stack) === -1 ||\n\t\t\t\t(stacked === undefined && item.stack === undefined)) {\n stacks.push(item.stack);\n }\n if (item.index === last) {\n break;\n }\n }\n if (!stacks.length) {\n stacks.push(undefined);\n }\n return stacks;\n }\n _getStackCount(index) {\n return this._getStacks(undefined, index).length;\n }\n _getStackIndex(datasetIndex, name, dataIndex) {\n const stacks = this._getStacks(datasetIndex, dataIndex);\n const index = (name !== undefined)\n ? stacks.indexOf(name)\n : -1;\n return (index === -1)\n ? stacks.length - 1\n : index;\n }\n _getRuler() {\n const opts = this.options;\n const meta = this._cachedMeta;\n const iScale = meta.iScale;\n const pixels = [];\n let i, ilen;\n for (i = 0, ilen = meta.data.length; i < ilen; ++i) {\n pixels.push(iScale.getPixelForValue(this.getParsed(i)[iScale.axis], i));\n }\n const barThickness = opts.barThickness;\n const min = barThickness || computeMinSampleSize(meta);\n return {\n min,\n pixels,\n start: iScale._startPixel,\n end: iScale._endPixel,\n stackCount: this._getStackCount(),\n scale: iScale,\n grouped: opts.grouped,\n ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage\n };\n }\n _calculateBarValuePixels(index) {\n const {_cachedMeta: {vScale, _stacked}, options: {base: baseValue, minBarLength}} = this;\n const actualBase = baseValue || 0;\n const parsed = this.getParsed(index);\n const custom = parsed._custom;\n const floating = isFloatBar(custom);\n let value = parsed[vScale.axis];\n let start = 0;\n let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value;\n let head, size;\n if (length !== value) {\n start = length - value;\n length = value;\n }\n if (floating) {\n value = custom.barStart;\n length = custom.barEnd - custom.barStart;\n if (value !== 0 && sign(value) !== sign(custom.barEnd)) {\n start = 0;\n }\n start += value;\n }\n const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start;\n let base = vScale.getPixelForValue(startValue);\n if (this.chart.getDataVisibility(index)) {\n head = vScale.getPixelForValue(start + length);\n } else {\n head = base;\n }\n size = head - base;\n if (Math.abs(size) < minBarLength) {\n size = barSign(size, vScale, actualBase) * minBarLength;\n if (value === actualBase) {\n base -= size / 2;\n }\n const startPixel = vScale.getPixelForDecimal(0);\n const endPixel = vScale.getPixelForDecimal(1);\n const min = Math.min(startPixel, endPixel);\n const max = Math.max(startPixel, endPixel);\n base = Math.max(Math.min(base, max), min);\n head = base + size;\n }\n if (base === vScale.getPixelForValue(actualBase)) {\n const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2;\n base += halfGrid;\n size -= halfGrid;\n }\n return {\n size,\n base,\n head,\n center: head + size / 2\n };\n }\n _calculateBarIndexPixels(index, ruler) {\n const scale = ruler.scale;\n const options = this.options;\n const skipNull = options.skipNull;\n const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity);\n let center, size;\n if (ruler.grouped) {\n const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount;\n const range = options.barThickness === 'flex'\n ? computeFlexCategoryTraits(index, ruler, options, stackCount)\n : computeFitCategoryTraits(index, ruler, options, stackCount);\n const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : undefined);\n center = range.start + (range.chunk * stackIndex) + (range.chunk / 2);\n size = Math.min(maxBarThickness, range.chunk * range.ratio);\n } else {\n center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index);\n size = Math.min(maxBarThickness, ruler.min * ruler.ratio);\n }\n return {\n base: center - size / 2,\n head: center + size / 2,\n center,\n size\n };\n }\n draw() {\n const meta = this._cachedMeta;\n const vScale = meta.vScale;\n const rects = meta.data;\n const ilen = rects.length;\n let i = 0;\n for (; i < ilen; ++i) {\n if (this.getParsed(i)[vScale.axis] !== null) {\n rects[i].draw(this._ctx);\n }\n }\n }\n}\nBarController.id = 'bar';\nBarController.defaults = {\n datasetElementType: false,\n dataElementType: 'bar',\n categoryPercentage: 0.8,\n barPercentage: 0.9,\n grouped: true,\n animations: {\n numbers: {\n type: 'number',\n properties: ['x', 'y', 'base', 'width', 'height']\n }\n }\n};\nBarController.overrides = {\n scales: {\n _index_: {\n type: 'category',\n offset: true,\n grid: {\n offset: true\n }\n },\n _value_: {\n type: 'linear',\n beginAtZero: true,\n }\n }\n};\n\nclass BubbleController extends DatasetController {\n initialize() {\n this.enableOptionSharing = true;\n super.initialize();\n }\n parsePrimitiveData(meta, data, start, count) {\n const parsed = super.parsePrimitiveData(meta, data, start, count);\n for (let i = 0; i < parsed.length; i++) {\n parsed[i]._custom = this.resolveDataElementOptions(i + start).radius;\n }\n return parsed;\n }\n parseArrayData(meta, data, start, count) {\n const parsed = super.parseArrayData(meta, data, start, count);\n for (let i = 0; i < parsed.length; i++) {\n const item = data[start + i];\n parsed[i]._custom = valueOrDefault(item[2], this.resolveDataElementOptions(i + start).radius);\n }\n return parsed;\n }\n parseObjectData(meta, data, start, count) {\n const parsed = super.parseObjectData(meta, data, start, count);\n for (let i = 0; i < parsed.length; i++) {\n const item = data[start + i];\n parsed[i]._custom = valueOrDefault(item && item.r && +item.r, this.resolveDataElementOptions(i + start).radius);\n }\n return parsed;\n }\n getMaxOverflow() {\n const data = this._cachedMeta.data;\n let max = 0;\n for (let i = data.length - 1; i >= 0; --i) {\n max = Math.max(max, data[i].size(this.resolveDataElementOptions(i)) / 2);\n }\n return max > 0 && max;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const {xScale, yScale} = meta;\n const parsed = this.getParsed(index);\n const x = xScale.getLabelForValue(parsed.x);\n const y = yScale.getLabelForValue(parsed.y);\n const r = parsed._custom;\n return {\n label: meta.label,\n value: '(' + x + ', ' + y + (r ? ', ' + r : '') + ')'\n };\n }\n update(mode) {\n const points = this._cachedMeta.data;\n this.updateElements(points, 0, points.length, mode);\n }\n updateElements(points, start, count, mode) {\n const reset = mode === 'reset';\n const {iScale, vScale} = this._cachedMeta;\n const firstOpts = this.resolveDataElementOptions(start, mode);\n const sharedOptions = this.getSharedOptions(firstOpts);\n const includeOptions = this.includeOptions(mode, sharedOptions);\n const iAxis = iScale.axis;\n const vAxis = vScale.axis;\n for (let i = start; i < start + count; i++) {\n const point = points[i];\n const parsed = !reset && this.getParsed(i);\n const properties = {};\n const iPixel = properties[iAxis] = reset ? iScale.getPixelForDecimal(0.5) : iScale.getPixelForValue(parsed[iAxis]);\n const vPixel = properties[vAxis] = reset ? vScale.getBasePixel() : vScale.getPixelForValue(parsed[vAxis]);\n properties.skip = isNaN(iPixel) || isNaN(vPixel);\n if (includeOptions) {\n properties.options = this.resolveDataElementOptions(i, point.active ? 'active' : mode);\n if (reset) {\n properties.options.radius = 0;\n }\n }\n this.updateElement(point, i, properties, mode);\n }\n this.updateSharedOptions(sharedOptions, mode, firstOpts);\n }\n resolveDataElementOptions(index, mode) {\n const parsed = this.getParsed(index);\n let values = super.resolveDataElementOptions(index, mode);\n if (values.$shared) {\n values = Object.assign({}, values, {$shared: false});\n }\n const radius = values.radius;\n if (mode !== 'active') {\n values.radius = 0;\n }\n values.radius += valueOrDefault(parsed && parsed._custom, radius);\n return values;\n }\n}\nBubbleController.id = 'bubble';\nBubbleController.defaults = {\n datasetElementType: false,\n dataElementType: 'point',\n animations: {\n numbers: {\n type: 'number',\n properties: ['x', 'y', 'borderWidth', 'radius']\n }\n }\n};\nBubbleController.overrides = {\n scales: {\n x: {\n type: 'linear'\n },\n y: {\n type: 'linear'\n }\n },\n plugins: {\n tooltip: {\n callbacks: {\n title() {\n return '';\n }\n }\n }\n }\n};\n\nfunction getRatioAndOffset(rotation, circumference, cutout) {\n let ratioX = 1;\n let ratioY = 1;\n let offsetX = 0;\n let offsetY = 0;\n if (circumference < TAU) {\n const startAngle = rotation;\n const endAngle = startAngle + circumference;\n const startX = Math.cos(startAngle);\n const startY = Math.sin(startAngle);\n const endX = Math.cos(endAngle);\n const endY = Math.sin(endAngle);\n const calcMax = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a, a * cutout, b, b * cutout);\n const calcMin = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a, a * cutout, b, b * cutout);\n const maxX = calcMax(0, startX, endX);\n const maxY = calcMax(HALF_PI, startY, endY);\n const minX = calcMin(PI, startX, endX);\n const minY = calcMin(PI + HALF_PI, startY, endY);\n ratioX = (maxX - minX) / 2;\n ratioY = (maxY - minY) / 2;\n offsetX = -(maxX + minX) / 2;\n offsetY = -(maxY + minY) / 2;\n }\n return {ratioX, ratioY, offsetX, offsetY};\n}\nclass DoughnutController extends DatasetController {\n constructor(chart, datasetIndex) {\n super(chart, datasetIndex);\n this.enableOptionSharing = true;\n this.innerRadius = undefined;\n this.outerRadius = undefined;\n this.offsetX = undefined;\n this.offsetY = undefined;\n }\n linkScales() {}\n parse(start, count) {\n const data = this.getDataset().data;\n const meta = this._cachedMeta;\n if (this._parsing === false) {\n meta._parsed = data;\n } else {\n let getter = (i) => +data[i];\n if (isObject(data[start])) {\n const {key = 'value'} = this._parsing;\n getter = (i) => +resolveObjectKey(data[i], key);\n }\n let i, ilen;\n for (i = start, ilen = start + count; i < ilen; ++i) {\n meta._parsed[i] = getter(i);\n }\n }\n }\n _getRotation() {\n return toRadians(this.options.rotation - 90);\n }\n _getCircumference() {\n return toRadians(this.options.circumference);\n }\n _getRotationExtents() {\n let min = TAU;\n let max = -TAU;\n for (let i = 0; i < this.chart.data.datasets.length; ++i) {\n if (this.chart.isDatasetVisible(i)) {\n const controller = this.chart.getDatasetMeta(i).controller;\n const rotation = controller._getRotation();\n const circumference = controller._getCircumference();\n min = Math.min(min, rotation);\n max = Math.max(max, rotation + circumference);\n }\n }\n return {\n rotation: min,\n circumference: max - min,\n };\n }\n update(mode) {\n const chart = this.chart;\n const {chartArea} = chart;\n const meta = this._cachedMeta;\n const arcs = meta.data;\n const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing;\n const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0);\n const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1);\n const chartWeight = this._getRingWeight(this.index);\n const {circumference, rotation} = this._getRotationExtents();\n const {ratioX, ratioY, offsetX, offsetY} = getRatioAndOffset(rotation, circumference, cutout);\n const maxWidth = (chartArea.width - spacing) / ratioX;\n const maxHeight = (chartArea.height - spacing) / ratioY;\n const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);\n const outerRadius = toDimension(this.options.radius, maxRadius);\n const innerRadius = Math.max(outerRadius * cutout, 0);\n const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal();\n this.offsetX = offsetX * outerRadius;\n this.offsetY = offsetY * outerRadius;\n meta.total = this.calculateTotal();\n this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index);\n this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0);\n this.updateElements(arcs, 0, arcs.length, mode);\n }\n _circumference(i, reset) {\n const opts = this.options;\n const meta = this._cachedMeta;\n const circumference = this._getCircumference();\n if ((reset && opts.animation.animateRotate) || !this.chart.getDataVisibility(i) || meta._parsed[i] === null || meta.data[i].hidden) {\n return 0;\n }\n return this.calculateCircumference(meta._parsed[i] * circumference / TAU);\n }\n updateElements(arcs, start, count, mode) {\n const reset = mode === 'reset';\n const chart = this.chart;\n const chartArea = chart.chartArea;\n const opts = chart.options;\n const animationOpts = opts.animation;\n const centerX = (chartArea.left + chartArea.right) / 2;\n const centerY = (chartArea.top + chartArea.bottom) / 2;\n const animateScale = reset && animationOpts.animateScale;\n const innerRadius = animateScale ? 0 : this.innerRadius;\n const outerRadius = animateScale ? 0 : this.outerRadius;\n const firstOpts = this.resolveDataElementOptions(start, mode);\n const sharedOptions = this.getSharedOptions(firstOpts);\n const includeOptions = this.includeOptions(mode, sharedOptions);\n let startAngle = this._getRotation();\n let i;\n for (i = 0; i < start; ++i) {\n startAngle += this._circumference(i, reset);\n }\n for (i = start; i < start + count; ++i) {\n const circumference = this._circumference(i, reset);\n const arc = arcs[i];\n const properties = {\n x: centerX + this.offsetX,\n y: centerY + this.offsetY,\n startAngle,\n endAngle: startAngle + circumference,\n circumference,\n outerRadius,\n innerRadius\n };\n if (includeOptions) {\n properties.options = sharedOptions || this.resolveDataElementOptions(i, arc.active ? 'active' : mode);\n }\n startAngle += circumference;\n this.updateElement(arc, i, properties, mode);\n }\n this.updateSharedOptions(sharedOptions, mode, firstOpts);\n }\n calculateTotal() {\n const meta = this._cachedMeta;\n const metaData = meta.data;\n let total = 0;\n let i;\n for (i = 0; i < metaData.length; i++) {\n const value = meta._parsed[i];\n if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i) && !metaData[i].hidden) {\n total += Math.abs(value);\n }\n }\n return total;\n }\n calculateCircumference(value) {\n const total = this._cachedMeta.total;\n if (total > 0 && !isNaN(value)) {\n return TAU * (Math.abs(value) / total);\n }\n return 0;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const chart = this.chart;\n const labels = chart.data.labels || [];\n const value = formatNumber(meta._parsed[index], chart.options.locale);\n return {\n label: labels[index] || '',\n value,\n };\n }\n getMaxBorderWidth(arcs) {\n let max = 0;\n const chart = this.chart;\n let i, ilen, meta, controller, options;\n if (!arcs) {\n for (i = 0, ilen = chart.data.datasets.length; i < ilen; ++i) {\n if (chart.isDatasetVisible(i)) {\n meta = chart.getDatasetMeta(i);\n arcs = meta.data;\n controller = meta.controller;\n break;\n }\n }\n }\n if (!arcs) {\n return 0;\n }\n for (i = 0, ilen = arcs.length; i < ilen; ++i) {\n options = controller.resolveDataElementOptions(i);\n if (options.borderAlign !== 'inner') {\n max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0);\n }\n }\n return max;\n }\n getMaxOffset(arcs) {\n let max = 0;\n for (let i = 0, ilen = arcs.length; i < ilen; ++i) {\n const options = this.resolveDataElementOptions(i);\n max = Math.max(max, options.offset || 0, options.hoverOffset || 0);\n }\n return max;\n }\n _getRingWeightOffset(datasetIndex) {\n let ringWeightOffset = 0;\n for (let i = 0; i < datasetIndex; ++i) {\n if (this.chart.isDatasetVisible(i)) {\n ringWeightOffset += this._getRingWeight(i);\n }\n }\n return ringWeightOffset;\n }\n _getRingWeight(datasetIndex) {\n return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0);\n }\n _getVisibleDatasetWeightTotal() {\n return this._getRingWeightOffset(this.chart.data.datasets.length) || 1;\n }\n}\nDoughnutController.id = 'doughnut';\nDoughnutController.defaults = {\n datasetElementType: false,\n dataElementType: 'arc',\n animation: {\n animateRotate: true,\n animateScale: false\n },\n animations: {\n numbers: {\n type: 'number',\n properties: ['circumference', 'endAngle', 'innerRadius', 'outerRadius', 'startAngle', 'x', 'y', 'offset', 'borderWidth', 'spacing']\n },\n },\n cutout: '50%',\n rotation: 0,\n circumference: 360,\n radius: '100%',\n spacing: 0,\n indexAxis: 'r',\n};\nDoughnutController.descriptors = {\n _scriptable: (name) => name !== 'spacing',\n _indexable: (name) => name !== 'spacing',\n};\nDoughnutController.overrides = {\n aspectRatio: 1,\n plugins: {\n legend: {\n labels: {\n generateLabels(chart) {\n const data = chart.data;\n if (data.labels.length && data.datasets.length) {\n const {labels: {pointStyle}} = chart.legend.options;\n return data.labels.map((label, i) => {\n const meta = chart.getDatasetMeta(0);\n const style = meta.controller.getStyle(i);\n return {\n text: label,\n fillStyle: style.backgroundColor,\n strokeStyle: style.borderColor,\n lineWidth: style.borderWidth,\n pointStyle: pointStyle,\n hidden: !chart.getDataVisibility(i),\n index: i\n };\n });\n }\n return [];\n }\n },\n onClick(e, legendItem, legend) {\n legend.chart.toggleDataVisibility(legendItem.index);\n legend.chart.update();\n }\n },\n tooltip: {\n callbacks: {\n title() {\n return '';\n },\n label(tooltipItem) {\n let dataLabel = tooltipItem.label;\n const value = ': ' + tooltipItem.formattedValue;\n if (isArray(dataLabel)) {\n dataLabel = dataLabel.slice();\n dataLabel[0] += value;\n } else {\n dataLabel += value;\n }\n return dataLabel;\n }\n }\n }\n }\n};\n\nclass LineController extends DatasetController {\n initialize() {\n this.enableOptionSharing = true;\n this.supportsDecimation = true;\n super.initialize();\n }\n update(mode) {\n const meta = this._cachedMeta;\n const {dataset: line, data: points = [], _dataset} = meta;\n const animationsDisabled = this.chart._animationsDisabled;\n let {start, count} = getStartAndCountOfVisiblePoints(meta, points, animationsDisabled);\n this._drawStart = start;\n this._drawCount = count;\n if (scaleRangesChanged(meta)) {\n start = 0;\n count = points.length;\n }\n line._chart = this.chart;\n line._datasetIndex = this.index;\n line._decimated = !!_dataset._decimated;\n line.points = points;\n const options = this.resolveDatasetElementOptions(mode);\n if (!this.options.showLine) {\n options.borderWidth = 0;\n }\n options.segment = this.options.segment;\n this.updateElement(line, undefined, {\n animated: !animationsDisabled,\n options\n }, mode);\n this.updateElements(points, start, count, mode);\n }\n updateElements(points, start, count, mode) {\n const reset = mode === 'reset';\n const {iScale, vScale, _stacked, _dataset} = this._cachedMeta;\n const firstOpts = this.resolveDataElementOptions(start, mode);\n const sharedOptions = this.getSharedOptions(firstOpts);\n const includeOptions = this.includeOptions(mode, sharedOptions);\n const iAxis = iScale.axis;\n const vAxis = vScale.axis;\n const {spanGaps, segment} = this.options;\n const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY;\n const directUpdate = this.chart._animationsDisabled || reset || mode === 'none';\n let prevParsed = start > 0 && this.getParsed(start - 1);\n for (let i = start; i < start + count; ++i) {\n const point = points[i];\n const parsed = this.getParsed(i);\n const properties = directUpdate ? point : {};\n const nullData = isNullOrUndef(parsed[vAxis]);\n const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i);\n const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i);\n properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData;\n properties.stop = i > 0 && (Math.abs(parsed[iAxis] - prevParsed[iAxis])) > maxGapLength;\n if (segment) {\n properties.parsed = parsed;\n properties.raw = _dataset.data[i];\n }\n if (includeOptions) {\n properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode);\n }\n if (!directUpdate) {\n this.updateElement(point, i, properties, mode);\n }\n prevParsed = parsed;\n }\n this.updateSharedOptions(sharedOptions, mode, firstOpts);\n }\n getMaxOverflow() {\n const meta = this._cachedMeta;\n const dataset = meta.dataset;\n const border = dataset.options && dataset.options.borderWidth || 0;\n const data = meta.data || [];\n if (!data.length) {\n return border;\n }\n const firstPoint = data[0].size(this.resolveDataElementOptions(0));\n const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1));\n return Math.max(border, firstPoint, lastPoint) / 2;\n }\n draw() {\n const meta = this._cachedMeta;\n meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis);\n super.draw();\n }\n}\nLineController.id = 'line';\nLineController.defaults = {\n datasetElementType: 'line',\n dataElementType: 'point',\n showLine: true,\n spanGaps: false,\n};\nLineController.overrides = {\n scales: {\n _index_: {\n type: 'category',\n },\n _value_: {\n type: 'linear',\n },\n }\n};\nfunction getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) {\n const pointCount = points.length;\n let start = 0;\n let count = pointCount;\n if (meta._sorted) {\n const {iScale, _parsed} = meta;\n const axis = iScale.axis;\n const {min, max, minDefined, maxDefined} = iScale.getUserBounds();\n if (minDefined) {\n start = _limitValue(Math.min(\n _lookupByKey(_parsed, iScale.axis, min).lo,\n animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo),\n 0, pointCount - 1);\n }\n if (maxDefined) {\n count = _limitValue(Math.max(\n _lookupByKey(_parsed, iScale.axis, max).hi + 1,\n animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max)).hi + 1),\n start, pointCount) - start;\n } else {\n count = pointCount - start;\n }\n }\n return {start, count};\n}\nfunction scaleRangesChanged(meta) {\n const {xScale, yScale, _scaleRanges} = meta;\n const newRanges = {\n xmin: xScale.min,\n xmax: xScale.max,\n ymin: yScale.min,\n ymax: yScale.max\n };\n if (!_scaleRanges) {\n meta._scaleRanges = newRanges;\n return true;\n }\n const changed = _scaleRanges.xmin !== xScale.min\n\t\t|| _scaleRanges.xmax !== xScale.max\n\t\t|| _scaleRanges.ymin !== yScale.min\n\t\t|| _scaleRanges.ymax !== yScale.max;\n Object.assign(_scaleRanges, newRanges);\n return changed;\n}\n\nclass PolarAreaController extends DatasetController {\n constructor(chart, datasetIndex) {\n super(chart, datasetIndex);\n this.innerRadius = undefined;\n this.outerRadius = undefined;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const chart = this.chart;\n const labels = chart.data.labels || [];\n const value = formatNumber(meta._parsed[index].r, chart.options.locale);\n return {\n label: labels[index] || '',\n value,\n };\n }\n parseObjectData(meta, data, start, count) {\n return _parseObjectDataRadialScale.bind(this)(meta, data, start, count);\n }\n update(mode) {\n const arcs = this._cachedMeta.data;\n this._updateRadius();\n this.updateElements(arcs, 0, arcs.length, mode);\n }\n getMinMax() {\n const meta = this._cachedMeta;\n const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY};\n meta.data.forEach((element, index) => {\n const parsed = this.getParsed(index).r;\n if (!isNaN(parsed) && this.chart.getDataVisibility(index)) {\n if (parsed < range.min) {\n range.min = parsed;\n }\n if (parsed > range.max) {\n range.max = parsed;\n }\n }\n });\n return range;\n }\n _updateRadius() {\n const chart = this.chart;\n const chartArea = chart.chartArea;\n const opts = chart.options;\n const minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);\n const outerRadius = Math.max(minSize / 2, 0);\n const innerRadius = Math.max(opts.cutoutPercentage ? (outerRadius / 100) * (opts.cutoutPercentage) : 1, 0);\n const radiusLength = (outerRadius - innerRadius) / chart.getVisibleDatasetCount();\n this.outerRadius = outerRadius - (radiusLength * this.index);\n this.innerRadius = this.outerRadius - radiusLength;\n }\n updateElements(arcs, start, count, mode) {\n const reset = mode === 'reset';\n const chart = this.chart;\n const opts = chart.options;\n const animationOpts = opts.animation;\n const scale = this._cachedMeta.rScale;\n const centerX = scale.xCenter;\n const centerY = scale.yCenter;\n const datasetStartAngle = scale.getIndexAngle(0) - 0.5 * PI;\n let angle = datasetStartAngle;\n let i;\n const defaultAngle = 360 / this.countVisibleElements();\n for (i = 0; i < start; ++i) {\n angle += this._computeAngle(i, mode, defaultAngle);\n }\n for (i = start; i < start + count; i++) {\n const arc = arcs[i];\n let startAngle = angle;\n let endAngle = angle + this._computeAngle(i, mode, defaultAngle);\n let outerRadius = chart.getDataVisibility(i) ? scale.getDistanceFromCenterForValue(this.getParsed(i).r) : 0;\n angle = endAngle;\n if (reset) {\n if (animationOpts.animateScale) {\n outerRadius = 0;\n }\n if (animationOpts.animateRotate) {\n startAngle = endAngle = datasetStartAngle;\n }\n }\n const properties = {\n x: centerX,\n y: centerY,\n innerRadius: 0,\n outerRadius,\n startAngle,\n endAngle,\n options: this.resolveDataElementOptions(i, arc.active ? 'active' : mode)\n };\n this.updateElement(arc, i, properties, mode);\n }\n }\n countVisibleElements() {\n const meta = this._cachedMeta;\n let count = 0;\n meta.data.forEach((element, index) => {\n if (!isNaN(this.getParsed(index).r) && this.chart.getDataVisibility(index)) {\n count++;\n }\n });\n return count;\n }\n _computeAngle(index, mode, defaultAngle) {\n return this.chart.getDataVisibility(index)\n ? toRadians(this.resolveDataElementOptions(index, mode).angle || defaultAngle)\n : 0;\n }\n}\nPolarAreaController.id = 'polarArea';\nPolarAreaController.defaults = {\n dataElementType: 'arc',\n animation: {\n animateRotate: true,\n animateScale: true\n },\n animations: {\n numbers: {\n type: 'number',\n properties: ['x', 'y', 'startAngle', 'endAngle', 'innerRadius', 'outerRadius']\n },\n },\n indexAxis: 'r',\n startAngle: 0,\n};\nPolarAreaController.overrides = {\n aspectRatio: 1,\n plugins: {\n legend: {\n labels: {\n generateLabels(chart) {\n const data = chart.data;\n if (data.labels.length && data.datasets.length) {\n const {labels: {pointStyle}} = chart.legend.options;\n return data.labels.map((label, i) => {\n const meta = chart.getDatasetMeta(0);\n const style = meta.controller.getStyle(i);\n return {\n text: label,\n fillStyle: style.backgroundColor,\n strokeStyle: style.borderColor,\n lineWidth: style.borderWidth,\n pointStyle: pointStyle,\n hidden: !chart.getDataVisibility(i),\n index: i\n };\n });\n }\n return [];\n }\n },\n onClick(e, legendItem, legend) {\n legend.chart.toggleDataVisibility(legendItem.index);\n legend.chart.update();\n }\n },\n tooltip: {\n callbacks: {\n title() {\n return '';\n },\n label(context) {\n return context.chart.data.labels[context.dataIndex] + ': ' + context.formattedValue;\n }\n }\n }\n },\n scales: {\n r: {\n type: 'radialLinear',\n angleLines: {\n display: false\n },\n beginAtZero: true,\n grid: {\n circular: true\n },\n pointLabels: {\n display: false\n },\n startAngle: 0\n }\n }\n};\n\nclass PieController extends DoughnutController {\n}\nPieController.id = 'pie';\nPieController.defaults = {\n cutout: 0,\n rotation: 0,\n circumference: 360,\n radius: '100%'\n};\n\nclass RadarController extends DatasetController {\n getLabelAndValue(index) {\n const vScale = this._cachedMeta.vScale;\n const parsed = this.getParsed(index);\n return {\n label: vScale.getLabels()[index],\n value: '' + vScale.getLabelForValue(parsed[vScale.axis])\n };\n }\n parseObjectData(meta, data, start, count) {\n return _parseObjectDataRadialScale.bind(this)(meta, data, start, count);\n }\n update(mode) {\n const meta = this._cachedMeta;\n const line = meta.dataset;\n const points = meta.data || [];\n const labels = meta.iScale.getLabels();\n line.points = points;\n if (mode !== 'resize') {\n const options = this.resolveDatasetElementOptions(mode);\n if (!this.options.showLine) {\n options.borderWidth = 0;\n }\n const properties = {\n _loop: true,\n _fullLoop: labels.length === points.length,\n options\n };\n this.updateElement(line, undefined, properties, mode);\n }\n this.updateElements(points, 0, points.length, mode);\n }\n updateElements(points, start, count, mode) {\n const scale = this._cachedMeta.rScale;\n const reset = mode === 'reset';\n for (let i = start; i < start + count; i++) {\n const point = points[i];\n const options = this.resolveDataElementOptions(i, point.active ? 'active' : mode);\n const pointPosition = scale.getPointPositionForValue(i, this.getParsed(i).r);\n const x = reset ? scale.xCenter : pointPosition.x;\n const y = reset ? scale.yCenter : pointPosition.y;\n const properties = {\n x,\n y,\n angle: pointPosition.angle,\n skip: isNaN(x) || isNaN(y),\n options\n };\n this.updateElement(point, i, properties, mode);\n }\n }\n}\nRadarController.id = 'radar';\nRadarController.defaults = {\n datasetElementType: 'line',\n dataElementType: 'point',\n indexAxis: 'r',\n showLine: true,\n elements: {\n line: {\n fill: 'start'\n }\n },\n};\nRadarController.overrides = {\n aspectRatio: 1,\n scales: {\n r: {\n type: 'radialLinear',\n }\n }\n};\n\nclass ScatterController extends LineController {\n}\nScatterController.id = 'scatter';\nScatterController.defaults = {\n showLine: false,\n fill: false\n};\nScatterController.overrides = {\n interaction: {\n mode: 'point'\n },\n plugins: {\n tooltip: {\n callbacks: {\n title() {\n return '';\n },\n label(item) {\n return '(' + item.label + ', ' + item.formattedValue + ')';\n }\n }\n }\n },\n scales: {\n x: {\n type: 'linear'\n },\n y: {\n type: 'linear'\n }\n }\n};\n\nvar controllers = /*#__PURE__*/Object.freeze({\n__proto__: null,\nBarController: BarController,\nBubbleController: BubbleController,\nDoughnutController: DoughnutController,\nLineController: LineController,\nPolarAreaController: PolarAreaController,\nPieController: PieController,\nRadarController: RadarController,\nScatterController: ScatterController\n});\n\nfunction abstract() {\n throw new Error('This method is not implemented: Check that a complete date adapter is provided.');\n}\nclass DateAdapter {\n constructor(options) {\n this.options = options || {};\n }\n formats() {\n return abstract();\n }\n parse(value, format) {\n return abstract();\n }\n format(timestamp, format) {\n return abstract();\n }\n add(timestamp, amount, unit) {\n return abstract();\n }\n diff(a, b, unit) {\n return abstract();\n }\n startOf(timestamp, unit, weekday) {\n return abstract();\n }\n endOf(timestamp, unit) {\n return abstract();\n }\n}\nDateAdapter.override = function(members) {\n Object.assign(DateAdapter.prototype, members);\n};\nvar adapters = {\n _date: DateAdapter\n};\n\nfunction binarySearch(metaset, axis, value, intersect) {\n const {controller, data, _sorted} = metaset;\n const iScale = controller._cachedMeta.iScale;\n if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) {\n const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;\n if (!intersect) {\n return lookupMethod(data, axis, value);\n } else if (controller._sharedOptions) {\n const el = data[0];\n const range = typeof el.getRange === 'function' && el.getRange(axis);\n if (range) {\n const start = lookupMethod(data, axis, value - range);\n const end = lookupMethod(data, axis, value + range);\n return {lo: start.lo, hi: end.hi};\n }\n }\n }\n return {lo: 0, hi: data.length - 1};\n}\nfunction evaluateInteractionItems(chart, axis, position, handler, intersect) {\n const metasets = chart.getSortedVisibleDatasetMetas();\n const value = position[axis];\n for (let i = 0, ilen = metasets.length; i < ilen; ++i) {\n const {index, data} = metasets[i];\n const {lo, hi} = binarySearch(metasets[i], axis, value, intersect);\n for (let j = lo; j <= hi; ++j) {\n const element = data[j];\n if (!element.skip) {\n handler(element, index, j);\n }\n }\n }\n}\nfunction getDistanceMetricForAxis(axis) {\n const useX = axis.indexOf('x') !== -1;\n const useY = axis.indexOf('y') !== -1;\n return function(pt1, pt2) {\n const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;\n const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;\n return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));\n };\n}\nfunction getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) {\n const items = [];\n if (!includeInvisible && !chart.isPointInArea(position)) {\n return items;\n }\n const evaluationFunc = function(element, datasetIndex, index) {\n if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) {\n return;\n }\n if (element.inRange(position.x, position.y, useFinalPosition)) {\n items.push({element, datasetIndex, index});\n }\n };\n evaluateInteractionItems(chart, axis, position, evaluationFunc, true);\n return items;\n}\nfunction getNearestRadialItems(chart, position, axis, useFinalPosition) {\n let items = [];\n function evaluationFunc(element, datasetIndex, index) {\n const {startAngle, endAngle} = element.getProps(['startAngle', 'endAngle'], useFinalPosition);\n const {angle} = getAngleFromPoint(element, {x: position.x, y: position.y});\n if (_angleBetween(angle, startAngle, endAngle)) {\n items.push({element, datasetIndex, index});\n }\n }\n evaluateInteractionItems(chart, axis, position, evaluationFunc);\n return items;\n}\nfunction getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {\n let items = [];\n const distanceMetric = getDistanceMetricForAxis(axis);\n let minDistance = Number.POSITIVE_INFINITY;\n function evaluationFunc(element, datasetIndex, index) {\n const inRange = element.inRange(position.x, position.y, useFinalPosition);\n if (intersect && !inRange) {\n return;\n }\n const center = element.getCenterPoint(useFinalPosition);\n const pointInArea = !!includeInvisible || chart.isPointInArea(center);\n if (!pointInArea && !inRange) {\n return;\n }\n const distance = distanceMetric(position, center);\n if (distance < minDistance) {\n items = [{element, datasetIndex, index}];\n minDistance = distance;\n } else if (distance === minDistance) {\n items.push({element, datasetIndex, index});\n }\n }\n evaluateInteractionItems(chart, axis, position, evaluationFunc);\n return items;\n}\nfunction getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {\n if (!includeInvisible && !chart.isPointInArea(position)) {\n return [];\n }\n return axis === 'r' && !intersect\n ? getNearestRadialItems(chart, position, axis, useFinalPosition)\n : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible);\n}\nfunction getAxisItems(chart, position, axis, intersect, useFinalPosition) {\n const items = [];\n const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange';\n let intersectsItem = false;\n evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index) => {\n if (element[rangeMethod](position[axis], useFinalPosition)) {\n items.push({element, datasetIndex, index});\n intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition);\n }\n });\n if (intersect && !intersectsItem) {\n return [];\n }\n return items;\n}\nvar Interaction = {\n evaluateInteractionItems,\n modes: {\n index(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n const axis = options.axis || 'x';\n const includeInvisible = options.includeInvisible || false;\n const items = options.intersect\n ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible)\n : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);\n const elements = [];\n if (!items.length) {\n return [];\n }\n chart.getSortedVisibleDatasetMetas().forEach((meta) => {\n const index = items[0].index;\n const element = meta.data[index];\n if (element && !element.skip) {\n elements.push({element, datasetIndex: meta.index, index});\n }\n });\n return elements;\n },\n dataset(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n const axis = options.axis || 'xy';\n const includeInvisible = options.includeInvisible || false;\n let items = options.intersect\n ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) :\n getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);\n if (items.length > 0) {\n const datasetIndex = items[0].datasetIndex;\n const data = chart.getDatasetMeta(datasetIndex).data;\n items = [];\n for (let i = 0; i < data.length; ++i) {\n items.push({element: data[i], datasetIndex, index: i});\n }\n }\n return items;\n },\n point(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n const axis = options.axis || 'xy';\n const includeInvisible = options.includeInvisible || false;\n return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible);\n },\n nearest(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n const axis = options.axis || 'xy';\n const includeInvisible = options.includeInvisible || false;\n return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible);\n },\n x(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n return getAxisItems(chart, position, 'x', options.intersect, useFinalPosition);\n },\n y(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n return getAxisItems(chart, position, 'y', options.intersect, useFinalPosition);\n }\n }\n};\n\nconst STATIC_POSITIONS = ['left', 'top', 'right', 'bottom'];\nfunction filterByPosition(array, position) {\n return array.filter(v => v.pos === position);\n}\nfunction filterDynamicPositionByAxis(array, axis) {\n return array.filter(v => STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis);\n}\nfunction sortByWeight(array, reverse) {\n return array.sort((a, b) => {\n const v0 = reverse ? b : a;\n const v1 = reverse ? a : b;\n return v0.weight === v1.weight ?\n v0.index - v1.index :\n v0.weight - v1.weight;\n });\n}\nfunction wrapBoxes(boxes) {\n const layoutBoxes = [];\n let i, ilen, box, pos, stack, stackWeight;\n for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) {\n box = boxes[i];\n ({position: pos, options: {stack, stackWeight = 1}} = box);\n layoutBoxes.push({\n index: i,\n box,\n pos,\n horizontal: box.isHorizontal(),\n weight: box.weight,\n stack: stack && (pos + stack),\n stackWeight\n });\n }\n return layoutBoxes;\n}\nfunction buildStacks(layouts) {\n const stacks = {};\n for (const wrap of layouts) {\n const {stack, pos, stackWeight} = wrap;\n if (!stack || !STATIC_POSITIONS.includes(pos)) {\n continue;\n }\n const _stack = stacks[stack] || (stacks[stack] = {count: 0, placed: 0, weight: 0, size: 0});\n _stack.count++;\n _stack.weight += stackWeight;\n }\n return stacks;\n}\nfunction setLayoutDims(layouts, params) {\n const stacks = buildStacks(layouts);\n const {vBoxMaxWidth, hBoxMaxHeight} = params;\n let i, ilen, layout;\n for (i = 0, ilen = layouts.length; i < ilen; ++i) {\n layout = layouts[i];\n const {fullSize} = layout.box;\n const stack = stacks[layout.stack];\n const factor = stack && layout.stackWeight / stack.weight;\n if (layout.horizontal) {\n layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;\n layout.height = hBoxMaxHeight;\n } else {\n layout.width = vBoxMaxWidth;\n layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;\n }\n }\n return stacks;\n}\nfunction buildLayoutBoxes(boxes) {\n const layoutBoxes = wrapBoxes(boxes);\n const fullSize = sortByWeight(layoutBoxes.filter(wrap => wrap.box.fullSize), true);\n const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true);\n const right = sortByWeight(filterByPosition(layoutBoxes, 'right'));\n const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true);\n const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom'));\n const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x');\n const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y');\n return {\n fullSize,\n leftAndTop: left.concat(top),\n rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),\n chartArea: filterByPosition(layoutBoxes, 'chartArea'),\n vertical: left.concat(right).concat(centerVertical),\n horizontal: top.concat(bottom).concat(centerHorizontal)\n };\n}\nfunction getCombinedMax(maxPadding, chartArea, a, b) {\n return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]);\n}\nfunction updateMaxPadding(maxPadding, boxPadding) {\n maxPadding.top = Math.max(maxPadding.top, boxPadding.top);\n maxPadding.left = Math.max(maxPadding.left, boxPadding.left);\n maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);\n maxPadding.right = Math.max(maxPadding.right, boxPadding.right);\n}\nfunction updateDims(chartArea, params, layout, stacks) {\n const {pos, box} = layout;\n const maxPadding = chartArea.maxPadding;\n if (!isObject(pos)) {\n if (layout.size) {\n chartArea[pos] -= layout.size;\n }\n const stack = stacks[layout.stack] || {size: 0, count: 1};\n stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);\n layout.size = stack.size / stack.count;\n chartArea[pos] += layout.size;\n }\n if (box.getPadding) {\n updateMaxPadding(maxPadding, box.getPadding());\n }\n const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right'));\n const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom'));\n const widthChanged = newWidth !== chartArea.w;\n const heightChanged = newHeight !== chartArea.h;\n chartArea.w = newWidth;\n chartArea.h = newHeight;\n return layout.horizontal\n ? {same: widthChanged, other: heightChanged}\n : {same: heightChanged, other: widthChanged};\n}\nfunction handleMaxPadding(chartArea) {\n const maxPadding = chartArea.maxPadding;\n function updatePos(pos) {\n const change = Math.max(maxPadding[pos] - chartArea[pos], 0);\n chartArea[pos] += change;\n return change;\n }\n chartArea.y += updatePos('top');\n chartArea.x += updatePos('left');\n updatePos('right');\n updatePos('bottom');\n}\nfunction getMargins(horizontal, chartArea) {\n const maxPadding = chartArea.maxPadding;\n function marginForPositions(positions) {\n const margin = {left: 0, top: 0, right: 0, bottom: 0};\n positions.forEach((pos) => {\n margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);\n });\n return margin;\n }\n return horizontal\n ? marginForPositions(['left', 'right'])\n : marginForPositions(['top', 'bottom']);\n}\nfunction fitBoxes(boxes, chartArea, params, stacks) {\n const refitBoxes = [];\n let i, ilen, layout, box, refit, changed;\n for (i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i) {\n layout = boxes[i];\n box = layout.box;\n box.update(\n layout.width || chartArea.w,\n layout.height || chartArea.h,\n getMargins(layout.horizontal, chartArea)\n );\n const {same, other} = updateDims(chartArea, params, layout, stacks);\n refit |= same && refitBoxes.length;\n changed = changed || other;\n if (!box.fullSize) {\n refitBoxes.push(layout);\n }\n }\n return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;\n}\nfunction setBoxDims(box, left, top, width, height) {\n box.top = top;\n box.left = left;\n box.right = left + width;\n box.bottom = top + height;\n box.width = width;\n box.height = height;\n}\nfunction placeBoxes(boxes, chartArea, params, stacks) {\n const userPadding = params.padding;\n let {x, y} = chartArea;\n for (const layout of boxes) {\n const box = layout.box;\n const stack = stacks[layout.stack] || {count: 1, placed: 0, weight: 1};\n const weight = (layout.stackWeight / stack.weight) || 1;\n if (layout.horizontal) {\n const width = chartArea.w * weight;\n const height = stack.size || box.height;\n if (defined(stack.start)) {\n y = stack.start;\n }\n if (box.fullSize) {\n setBoxDims(box, userPadding.left, y, params.outerWidth - userPadding.right - userPadding.left, height);\n } else {\n setBoxDims(box, chartArea.left + stack.placed, y, width, height);\n }\n stack.start = y;\n stack.placed += width;\n y = box.bottom;\n } else {\n const height = chartArea.h * weight;\n const width = stack.size || box.width;\n if (defined(stack.start)) {\n x = stack.start;\n }\n if (box.fullSize) {\n setBoxDims(box, x, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);\n } else {\n setBoxDims(box, x, chartArea.top + stack.placed, width, height);\n }\n stack.start = x;\n stack.placed += height;\n x = box.right;\n }\n }\n chartArea.x = x;\n chartArea.y = y;\n}\ndefaults.set('layout', {\n autoPadding: true,\n padding: {\n top: 0,\n right: 0,\n bottom: 0,\n left: 0\n }\n});\nvar layouts = {\n addBox(chart, item) {\n if (!chart.boxes) {\n chart.boxes = [];\n }\n item.fullSize = item.fullSize || false;\n item.position = item.position || 'top';\n item.weight = item.weight || 0;\n item._layers = item._layers || function() {\n return [{\n z: 0,\n draw(chartArea) {\n item.draw(chartArea);\n }\n }];\n };\n chart.boxes.push(item);\n },\n removeBox(chart, layoutItem) {\n const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;\n if (index !== -1) {\n chart.boxes.splice(index, 1);\n }\n },\n configure(chart, item, options) {\n item.fullSize = options.fullSize;\n item.position = options.position;\n item.weight = options.weight;\n },\n update(chart, width, height, minPadding) {\n if (!chart) {\n return;\n }\n const padding = toPadding(chart.options.layout.padding);\n const availableWidth = Math.max(width - padding.width, 0);\n const availableHeight = Math.max(height - padding.height, 0);\n const boxes = buildLayoutBoxes(chart.boxes);\n const verticalBoxes = boxes.vertical;\n const horizontalBoxes = boxes.horizontal;\n each(chart.boxes, box => {\n if (typeof box.beforeLayout === 'function') {\n box.beforeLayout();\n }\n });\n const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) =>\n wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;\n const params = Object.freeze({\n outerWidth: width,\n outerHeight: height,\n padding,\n availableWidth,\n availableHeight,\n vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,\n hBoxMaxHeight: availableHeight / 2\n });\n const maxPadding = Object.assign({}, padding);\n updateMaxPadding(maxPadding, toPadding(minPadding));\n const chartArea = Object.assign({\n maxPadding,\n w: availableWidth,\n h: availableHeight,\n x: padding.left,\n y: padding.top\n }, padding);\n const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);\n fitBoxes(boxes.fullSize, chartArea, params, stacks);\n fitBoxes(verticalBoxes, chartArea, params, stacks);\n if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {\n fitBoxes(verticalBoxes, chartArea, params, stacks);\n }\n handleMaxPadding(chartArea);\n placeBoxes(boxes.leftAndTop, chartArea, params, stacks);\n chartArea.x += chartArea.w;\n chartArea.y += chartArea.h;\n placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);\n chart.chartArea = {\n left: chartArea.left,\n top: chartArea.top,\n right: chartArea.left + chartArea.w,\n bottom: chartArea.top + chartArea.h,\n height: chartArea.h,\n width: chartArea.w,\n };\n each(boxes.chartArea, (layout) => {\n const box = layout.box;\n Object.assign(box, chart.chartArea);\n box.update(chartArea.w, chartArea.h, {left: 0, top: 0, right: 0, bottom: 0});\n });\n }\n};\n\nclass BasePlatform {\n acquireContext(canvas, aspectRatio) {}\n releaseContext(context) {\n return false;\n }\n addEventListener(chart, type, listener) {}\n removeEventListener(chart, type, listener) {}\n getDevicePixelRatio() {\n return 1;\n }\n getMaximumSize(element, width, height, aspectRatio) {\n width = Math.max(0, width || element.width);\n height = height || element.height;\n return {\n width,\n height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)\n };\n }\n isAttached(canvas) {\n return true;\n }\n updateConfig(config) {\n }\n}\n\nclass BasicPlatform extends BasePlatform {\n acquireContext(item) {\n return item && item.getContext && item.getContext('2d') || null;\n }\n updateConfig(config) {\n config.options.animation = false;\n }\n}\n\nconst EXPANDO_KEY = '$chartjs';\nconst EVENT_TYPES = {\n touchstart: 'mousedown',\n touchmove: 'mousemove',\n touchend: 'mouseup',\n pointerenter: 'mouseenter',\n pointerdown: 'mousedown',\n pointermove: 'mousemove',\n pointerup: 'mouseup',\n pointerleave: 'mouseout',\n pointerout: 'mouseout'\n};\nconst isNullOrEmpty = value => value === null || value === '';\nfunction initCanvas(canvas, aspectRatio) {\n const style = canvas.style;\n const renderHeight = canvas.getAttribute('height');\n const renderWidth = canvas.getAttribute('width');\n canvas[EXPANDO_KEY] = {\n initial: {\n height: renderHeight,\n width: renderWidth,\n style: {\n display: style.display,\n height: style.height,\n width: style.width\n }\n }\n };\n style.display = style.display || 'block';\n style.boxSizing = style.boxSizing || 'border-box';\n if (isNullOrEmpty(renderWidth)) {\n const displayWidth = readUsedSize(canvas, 'width');\n if (displayWidth !== undefined) {\n canvas.width = displayWidth;\n }\n }\n if (isNullOrEmpty(renderHeight)) {\n if (canvas.style.height === '') {\n canvas.height = canvas.width / (aspectRatio || 2);\n } else {\n const displayHeight = readUsedSize(canvas, 'height');\n if (displayHeight !== undefined) {\n canvas.height = displayHeight;\n }\n }\n }\n return canvas;\n}\nconst eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false;\nfunction addListener(node, type, listener) {\n node.addEventListener(type, listener, eventListenerOptions);\n}\nfunction removeListener(chart, type, listener) {\n chart.canvas.removeEventListener(type, listener, eventListenerOptions);\n}\nfunction fromNativeEvent(event, chart) {\n const type = EVENT_TYPES[event.type] || event.type;\n const {x, y} = getRelativePosition(event, chart);\n return {\n type,\n chart,\n native: event,\n x: x !== undefined ? x : null,\n y: y !== undefined ? y : null,\n };\n}\nfunction nodeListContains(nodeList, canvas) {\n for (const node of nodeList) {\n if (node === canvas || node.contains(canvas)) {\n return true;\n }\n }\n}\nfunction createAttachObserver(chart, type, listener) {\n const canvas = chart.canvas;\n const observer = new MutationObserver(entries => {\n let trigger = false;\n for (const entry of entries) {\n trigger = trigger || nodeListContains(entry.addedNodes, canvas);\n trigger = trigger && !nodeListContains(entry.removedNodes, canvas);\n }\n if (trigger) {\n listener();\n }\n });\n observer.observe(document, {childList: true, subtree: true});\n return observer;\n}\nfunction createDetachObserver(chart, type, listener) {\n const canvas = chart.canvas;\n const observer = new MutationObserver(entries => {\n let trigger = false;\n for (const entry of entries) {\n trigger = trigger || nodeListContains(entry.removedNodes, canvas);\n trigger = trigger && !nodeListContains(entry.addedNodes, canvas);\n }\n if (trigger) {\n listener();\n }\n });\n observer.observe(document, {childList: true, subtree: true});\n return observer;\n}\nconst drpListeningCharts = new Map();\nlet oldDevicePixelRatio = 0;\nfunction onWindowResize() {\n const dpr = window.devicePixelRatio;\n if (dpr === oldDevicePixelRatio) {\n return;\n }\n oldDevicePixelRatio = dpr;\n drpListeningCharts.forEach((resize, chart) => {\n if (chart.currentDevicePixelRatio !== dpr) {\n resize();\n }\n });\n}\nfunction listenDevicePixelRatioChanges(chart, resize) {\n if (!drpListeningCharts.size) {\n window.addEventListener('resize', onWindowResize);\n }\n drpListeningCharts.set(chart, resize);\n}\nfunction unlistenDevicePixelRatioChanges(chart) {\n drpListeningCharts.delete(chart);\n if (!drpListeningCharts.size) {\n window.removeEventListener('resize', onWindowResize);\n }\n}\nfunction createResizeObserver(chart, type, listener) {\n const canvas = chart.canvas;\n const container = canvas && _getParentNode(canvas);\n if (!container) {\n return;\n }\n const resize = throttled((width, height) => {\n const w = container.clientWidth;\n listener(width, height);\n if (w < container.clientWidth) {\n listener();\n }\n }, window);\n const observer = new ResizeObserver(entries => {\n const entry = entries[0];\n const width = entry.contentRect.width;\n const height = entry.contentRect.height;\n if (width === 0 && height === 0) {\n return;\n }\n resize(width, height);\n });\n observer.observe(container);\n listenDevicePixelRatioChanges(chart, resize);\n return observer;\n}\nfunction releaseObserver(chart, type, observer) {\n if (observer) {\n observer.disconnect();\n }\n if (type === 'resize') {\n unlistenDevicePixelRatioChanges(chart);\n }\n}\nfunction createProxyAndListen(chart, type, listener) {\n const canvas = chart.canvas;\n const proxy = throttled((event) => {\n if (chart.ctx !== null) {\n listener(fromNativeEvent(event, chart));\n }\n }, chart, (args) => {\n const event = args[0];\n return [event, event.offsetX, event.offsetY];\n });\n addListener(canvas, type, proxy);\n return proxy;\n}\nclass DomPlatform extends BasePlatform {\n acquireContext(canvas, aspectRatio) {\n const context = canvas && canvas.getContext && canvas.getContext('2d');\n if (context && context.canvas === canvas) {\n initCanvas(canvas, aspectRatio);\n return context;\n }\n return null;\n }\n releaseContext(context) {\n const canvas = context.canvas;\n if (!canvas[EXPANDO_KEY]) {\n return false;\n }\n const initial = canvas[EXPANDO_KEY].initial;\n ['height', 'width'].forEach((prop) => {\n const value = initial[prop];\n if (isNullOrUndef(value)) {\n canvas.removeAttribute(prop);\n } else {\n canvas.setAttribute(prop, value);\n }\n });\n const style = initial.style || {};\n Object.keys(style).forEach((key) => {\n canvas.style[key] = style[key];\n });\n canvas.width = canvas.width;\n delete canvas[EXPANDO_KEY];\n return true;\n }\n addEventListener(chart, type, listener) {\n this.removeEventListener(chart, type);\n const proxies = chart.$proxies || (chart.$proxies = {});\n const handlers = {\n attach: createAttachObserver,\n detach: createDetachObserver,\n resize: createResizeObserver\n };\n const handler = handlers[type] || createProxyAndListen;\n proxies[type] = handler(chart, type, listener);\n }\n removeEventListener(chart, type) {\n const proxies = chart.$proxies || (chart.$proxies = {});\n const proxy = proxies[type];\n if (!proxy) {\n return;\n }\n const handlers = {\n attach: releaseObserver,\n detach: releaseObserver,\n resize: releaseObserver\n };\n const handler = handlers[type] || removeListener;\n handler(chart, type, proxy);\n proxies[type] = undefined;\n }\n getDevicePixelRatio() {\n return window.devicePixelRatio;\n }\n getMaximumSize(canvas, width, height, aspectRatio) {\n return getMaximumSize(canvas, width, height, aspectRatio);\n }\n isAttached(canvas) {\n const container = _getParentNode(canvas);\n return !!(container && container.isConnected);\n }\n}\n\nfunction _detectPlatform(canvas) {\n if (!_isDomSupported() || (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas)) {\n return BasicPlatform;\n }\n return DomPlatform;\n}\n\nclass Element {\n constructor() {\n this.x = undefined;\n this.y = undefined;\n this.active = false;\n this.options = undefined;\n this.$animations = undefined;\n }\n tooltipPosition(useFinalPosition) {\n const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n return {x, y};\n }\n hasValue() {\n return isNumber(this.x) && isNumber(this.y);\n }\n getProps(props, final) {\n const anims = this.$animations;\n if (!final || !anims) {\n return this;\n }\n const ret = {};\n props.forEach(prop => {\n ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop];\n });\n return ret;\n }\n}\nElement.defaults = {};\nElement.defaultRoutes = undefined;\n\nconst formatters = {\n values(value) {\n return isArray(value) ? value : '' + value;\n },\n numeric(tickValue, index, ticks) {\n if (tickValue === 0) {\n return '0';\n }\n const locale = this.chart.options.locale;\n let notation;\n let delta = tickValue;\n if (ticks.length > 1) {\n const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));\n if (maxTick < 1e-4 || maxTick > 1e+15) {\n notation = 'scientific';\n }\n delta = calculateDelta(tickValue, ticks);\n }\n const logDelta = log10(Math.abs(delta));\n const numDecimal = Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);\n const options = {notation, minimumFractionDigits: numDecimal, maximumFractionDigits: numDecimal};\n Object.assign(options, this.options.ticks.format);\n return formatNumber(tickValue, locale, options);\n },\n logarithmic(tickValue, index, ticks) {\n if (tickValue === 0) {\n return '0';\n }\n const remain = tickValue / (Math.pow(10, Math.floor(log10(tickValue))));\n if (remain === 1 || remain === 2 || remain === 5) {\n return formatters.numeric.call(this, tickValue, index, ticks);\n }\n return '';\n }\n};\nfunction calculateDelta(tickValue, ticks) {\n let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;\n if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {\n delta = tickValue - Math.floor(tickValue);\n }\n return delta;\n}\nvar Ticks = {formatters};\n\ndefaults.set('scale', {\n display: true,\n offset: false,\n reverse: false,\n beginAtZero: false,\n bounds: 'ticks',\n grace: 0,\n grid: {\n display: true,\n lineWidth: 1,\n drawBorder: true,\n drawOnChartArea: true,\n drawTicks: true,\n tickLength: 8,\n tickWidth: (_ctx, options) => options.lineWidth,\n tickColor: (_ctx, options) => options.color,\n offset: false,\n borderDash: [],\n borderDashOffset: 0.0,\n borderWidth: 1\n },\n title: {\n display: false,\n text: '',\n padding: {\n top: 4,\n bottom: 4\n }\n },\n ticks: {\n minRotation: 0,\n maxRotation: 50,\n mirror: false,\n textStrokeWidth: 0,\n textStrokeColor: '',\n padding: 3,\n display: true,\n autoSkip: true,\n autoSkipPadding: 3,\n labelOffset: 0,\n callback: Ticks.formatters.values,\n minor: {},\n major: {},\n align: 'center',\n crossAlign: 'near',\n showLabelBackdrop: false,\n backdropColor: 'rgba(255, 255, 255, 0.75)',\n backdropPadding: 2,\n }\n});\ndefaults.route('scale.ticks', 'color', '', 'color');\ndefaults.route('scale.grid', 'color', '', 'borderColor');\ndefaults.route('scale.grid', 'borderColor', '', 'borderColor');\ndefaults.route('scale.title', 'color', '', 'color');\ndefaults.describe('scale', {\n _fallback: false,\n _scriptable: (name) => !name.startsWith('before') && !name.startsWith('after') && name !== 'callback' && name !== 'parser',\n _indexable: (name) => name !== 'borderDash' && name !== 'tickBorderDash',\n});\ndefaults.describe('scales', {\n _fallback: 'scale',\n});\ndefaults.describe('scale.ticks', {\n _scriptable: (name) => name !== 'backdropPadding' && name !== 'callback',\n _indexable: (name) => name !== 'backdropPadding',\n});\n\nfunction autoSkip(scale, ticks) {\n const tickOpts = scale.options.ticks;\n const ticksLimit = tickOpts.maxTicksLimit || determineMaxTicks(scale);\n const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];\n const numMajorIndices = majorIndices.length;\n const first = majorIndices[0];\n const last = majorIndices[numMajorIndices - 1];\n const newTicks = [];\n if (numMajorIndices > ticksLimit) {\n skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);\n return newTicks;\n }\n const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);\n if (numMajorIndices > 0) {\n let i, ilen;\n const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;\n skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);\n for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) {\n skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]);\n }\n skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);\n return newTicks;\n }\n skip(ticks, newTicks, spacing);\n return newTicks;\n}\nfunction determineMaxTicks(scale) {\n const offset = scale.options.offset;\n const tickLength = scale._tickSize();\n const maxScale = scale._length / tickLength + (offset ? 0 : 1);\n const maxChart = scale._maxLength / tickLength;\n return Math.floor(Math.min(maxScale, maxChart));\n}\nfunction calculateSpacing(majorIndices, ticks, ticksLimit) {\n const evenMajorSpacing = getEvenSpacing(majorIndices);\n const spacing = ticks.length / ticksLimit;\n if (!evenMajorSpacing) {\n return Math.max(spacing, 1);\n }\n const factors = _factorize(evenMajorSpacing);\n for (let i = 0, ilen = factors.length - 1; i < ilen; i++) {\n const factor = factors[i];\n if (factor > spacing) {\n return factor;\n }\n }\n return Math.max(spacing, 1);\n}\nfunction getMajorIndices(ticks) {\n const result = [];\n let i, ilen;\n for (i = 0, ilen = ticks.length; i < ilen; i++) {\n if (ticks[i].major) {\n result.push(i);\n }\n }\n return result;\n}\nfunction skipMajors(ticks, newTicks, majorIndices, spacing) {\n let count = 0;\n let next = majorIndices[0];\n let i;\n spacing = Math.ceil(spacing);\n for (i = 0; i < ticks.length; i++) {\n if (i === next) {\n newTicks.push(ticks[i]);\n count++;\n next = majorIndices[count * spacing];\n }\n }\n}\nfunction skip(ticks, newTicks, spacing, majorStart, majorEnd) {\n const start = valueOrDefault(majorStart, 0);\n const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);\n let count = 0;\n let length, i, next;\n spacing = Math.ceil(spacing);\n if (majorEnd) {\n length = majorEnd - majorStart;\n spacing = length / Math.floor(length / spacing);\n }\n next = start;\n while (next < 0) {\n count++;\n next = Math.round(start + count * spacing);\n }\n for (i = Math.max(start, 0); i < end; i++) {\n if (i === next) {\n newTicks.push(ticks[i]);\n count++;\n next = Math.round(start + count * spacing);\n }\n }\n}\nfunction getEvenSpacing(arr) {\n const len = arr.length;\n let i, diff;\n if (len < 2) {\n return false;\n }\n for (diff = arr[0], i = 1; i < len; ++i) {\n if (arr[i] - arr[i - 1] !== diff) {\n return false;\n }\n }\n return diff;\n}\n\nconst reverseAlign = (align) => align === 'left' ? 'right' : align === 'right' ? 'left' : align;\nconst offsetFromEdge = (scale, edge, offset) => edge === 'top' || edge === 'left' ? scale[edge] + offset : scale[edge] - offset;\nfunction sample(arr, numItems) {\n const result = [];\n const increment = arr.length / numItems;\n const len = arr.length;\n let i = 0;\n for (; i < len; i += increment) {\n result.push(arr[Math.floor(i)]);\n }\n return result;\n}\nfunction getPixelForGridLine(scale, index, offsetGridLines) {\n const length = scale.ticks.length;\n const validIndex = Math.min(index, length - 1);\n const start = scale._startPixel;\n const end = scale._endPixel;\n const epsilon = 1e-6;\n let lineValue = scale.getPixelForTick(validIndex);\n let offset;\n if (offsetGridLines) {\n if (length === 1) {\n offset = Math.max(lineValue - start, end - lineValue);\n } else if (index === 0) {\n offset = (scale.getPixelForTick(1) - lineValue) / 2;\n } else {\n offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2;\n }\n lineValue += validIndex < index ? offset : -offset;\n if (lineValue < start - epsilon || lineValue > end + epsilon) {\n return;\n }\n }\n return lineValue;\n}\nfunction garbageCollect(caches, length) {\n each(caches, (cache) => {\n const gc = cache.gc;\n const gcLen = gc.length / 2;\n let i;\n if (gcLen > length) {\n for (i = 0; i < gcLen; ++i) {\n delete cache.data[gc[i]];\n }\n gc.splice(0, gcLen);\n }\n });\n}\nfunction getTickMarkLength(options) {\n return options.drawTicks ? options.tickLength : 0;\n}\nfunction getTitleHeight(options, fallback) {\n if (!options.display) {\n return 0;\n }\n const font = toFont(options.font, fallback);\n const padding = toPadding(options.padding);\n const lines = isArray(options.text) ? options.text.length : 1;\n return (lines * font.lineHeight) + padding.height;\n}\nfunction createScaleContext(parent, scale) {\n return createContext(parent, {\n scale,\n type: 'scale'\n });\n}\nfunction createTickContext(parent, index, tick) {\n return createContext(parent, {\n tick,\n index,\n type: 'tick'\n });\n}\nfunction titleAlign(align, position, reverse) {\n let ret = _toLeftRightCenter(align);\n if ((reverse && position !== 'right') || (!reverse && position === 'right')) {\n ret = reverseAlign(ret);\n }\n return ret;\n}\nfunction titleArgs(scale, offset, position, align) {\n const {top, left, bottom, right, chart} = scale;\n const {chartArea, scales} = chart;\n let rotation = 0;\n let maxWidth, titleX, titleY;\n const height = bottom - top;\n const width = right - left;\n if (scale.isHorizontal()) {\n titleX = _alignStartEnd(align, left, right);\n if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;\n } else if (position === 'center') {\n titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;\n } else {\n titleY = offsetFromEdge(scale, position, offset);\n }\n maxWidth = right - left;\n } else {\n if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;\n } else if (position === 'center') {\n titleX = (chartArea.left + chartArea.right) / 2 - width + offset;\n } else {\n titleX = offsetFromEdge(scale, position, offset);\n }\n titleY = _alignStartEnd(align, bottom, top);\n rotation = position === 'left' ? -HALF_PI : HALF_PI;\n }\n return {titleX, titleY, maxWidth, rotation};\n}\nclass Scale extends Element {\n constructor(cfg) {\n super();\n this.id = cfg.id;\n this.type = cfg.type;\n this.options = undefined;\n this.ctx = cfg.ctx;\n this.chart = cfg.chart;\n this.top = undefined;\n this.bottom = undefined;\n this.left = undefined;\n this.right = undefined;\n this.width = undefined;\n this.height = undefined;\n this._margins = {\n left: 0,\n right: 0,\n top: 0,\n bottom: 0\n };\n this.maxWidth = undefined;\n this.maxHeight = undefined;\n this.paddingTop = undefined;\n this.paddingBottom = undefined;\n this.paddingLeft = undefined;\n this.paddingRight = undefined;\n this.axis = undefined;\n this.labelRotation = undefined;\n this.min = undefined;\n this.max = undefined;\n this._range = undefined;\n this.ticks = [];\n this._gridLineItems = null;\n this._labelItems = null;\n this._labelSizes = null;\n this._length = 0;\n this._maxLength = 0;\n this._longestTextCache = {};\n this._startPixel = undefined;\n this._endPixel = undefined;\n this._reversePixels = false;\n this._userMax = undefined;\n this._userMin = undefined;\n this._suggestedMax = undefined;\n this._suggestedMin = undefined;\n this._ticksLength = 0;\n this._borderValue = 0;\n this._cache = {};\n this._dataLimitsCached = false;\n this.$context = undefined;\n }\n init(options) {\n this.options = options.setContext(this.getContext());\n this.axis = options.axis;\n this._userMin = this.parse(options.min);\n this._userMax = this.parse(options.max);\n this._suggestedMin = this.parse(options.suggestedMin);\n this._suggestedMax = this.parse(options.suggestedMax);\n }\n parse(raw, index) {\n return raw;\n }\n getUserBounds() {\n let {_userMin, _userMax, _suggestedMin, _suggestedMax} = this;\n _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);\n _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);\n _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);\n _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);\n return {\n min: finiteOrDefault(_userMin, _suggestedMin),\n max: finiteOrDefault(_userMax, _suggestedMax),\n minDefined: isNumberFinite(_userMin),\n maxDefined: isNumberFinite(_userMax)\n };\n }\n getMinMax(canStack) {\n let {min, max, minDefined, maxDefined} = this.getUserBounds();\n let range;\n if (minDefined && maxDefined) {\n return {min, max};\n }\n const metas = this.getMatchingVisibleMetas();\n for (let i = 0, ilen = metas.length; i < ilen; ++i) {\n range = metas[i].controller.getMinMax(this, canStack);\n if (!minDefined) {\n min = Math.min(min, range.min);\n }\n if (!maxDefined) {\n max = Math.max(max, range.max);\n }\n }\n min = maxDefined && min > max ? max : min;\n max = minDefined && min > max ? min : max;\n return {\n min: finiteOrDefault(min, finiteOrDefault(max, min)),\n max: finiteOrDefault(max, finiteOrDefault(min, max))\n };\n }\n getPadding() {\n return {\n left: this.paddingLeft || 0,\n top: this.paddingTop || 0,\n right: this.paddingRight || 0,\n bottom: this.paddingBottom || 0\n };\n }\n getTicks() {\n return this.ticks;\n }\n getLabels() {\n const data = this.chart.data;\n return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];\n }\n beforeLayout() {\n this._cache = {};\n this._dataLimitsCached = false;\n }\n beforeUpdate() {\n callback(this.options.beforeUpdate, [this]);\n }\n update(maxWidth, maxHeight, margins) {\n const {beginAtZero, grace, ticks: tickOpts} = this.options;\n const sampleSize = tickOpts.sampleSize;\n this.beforeUpdate();\n this.maxWidth = maxWidth;\n this.maxHeight = maxHeight;\n this._margins = margins = Object.assign({\n left: 0,\n right: 0,\n top: 0,\n bottom: 0\n }, margins);\n this.ticks = null;\n this._labelSizes = null;\n this._gridLineItems = null;\n this._labelItems = null;\n this.beforeSetDimensions();\n this.setDimensions();\n this.afterSetDimensions();\n this._maxLength = this.isHorizontal()\n ? this.width + margins.left + margins.right\n : this.height + margins.top + margins.bottom;\n if (!this._dataLimitsCached) {\n this.beforeDataLimits();\n this.determineDataLimits();\n this.afterDataLimits();\n this._range = _addGrace(this, grace, beginAtZero);\n this._dataLimitsCached = true;\n }\n this.beforeBuildTicks();\n this.ticks = this.buildTicks() || [];\n this.afterBuildTicks();\n const samplingEnabled = sampleSize < this.ticks.length;\n this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);\n this.configure();\n this.beforeCalculateLabelRotation();\n this.calculateLabelRotation();\n this.afterCalculateLabelRotation();\n if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto')) {\n this.ticks = autoSkip(this, this.ticks);\n this._labelSizes = null;\n this.afterAutoSkip();\n }\n if (samplingEnabled) {\n this._convertTicksToLabels(this.ticks);\n }\n this.beforeFit();\n this.fit();\n this.afterFit();\n this.afterUpdate();\n }\n configure() {\n let reversePixels = this.options.reverse;\n let startPixel, endPixel;\n if (this.isHorizontal()) {\n startPixel = this.left;\n endPixel = this.right;\n } else {\n startPixel = this.top;\n endPixel = this.bottom;\n reversePixels = !reversePixels;\n }\n this._startPixel = startPixel;\n this._endPixel = endPixel;\n this._reversePixels = reversePixels;\n this._length = endPixel - startPixel;\n this._alignToPixels = this.options.alignToPixels;\n }\n afterUpdate() {\n callback(this.options.afterUpdate, [this]);\n }\n beforeSetDimensions() {\n callback(this.options.beforeSetDimensions, [this]);\n }\n setDimensions() {\n if (this.isHorizontal()) {\n this.width = this.maxWidth;\n this.left = 0;\n this.right = this.width;\n } else {\n this.height = this.maxHeight;\n this.top = 0;\n this.bottom = this.height;\n }\n this.paddingLeft = 0;\n this.paddingTop = 0;\n this.paddingRight = 0;\n this.paddingBottom = 0;\n }\n afterSetDimensions() {\n callback(this.options.afterSetDimensions, [this]);\n }\n _callHooks(name) {\n this.chart.notifyPlugins(name, this.getContext());\n callback(this.options[name], [this]);\n }\n beforeDataLimits() {\n this._callHooks('beforeDataLimits');\n }\n determineDataLimits() {}\n afterDataLimits() {\n this._callHooks('afterDataLimits');\n }\n beforeBuildTicks() {\n this._callHooks('beforeBuildTicks');\n }\n buildTicks() {\n return [];\n }\n afterBuildTicks() {\n this._callHooks('afterBuildTicks');\n }\n beforeTickToLabelConversion() {\n callback(this.options.beforeTickToLabelConversion, [this]);\n }\n generateTickLabels(ticks) {\n const tickOpts = this.options.ticks;\n let i, ilen, tick;\n for (i = 0, ilen = ticks.length; i < ilen; i++) {\n tick = ticks[i];\n tick.label = callback(tickOpts.callback, [tick.value, i, ticks], this);\n }\n }\n afterTickToLabelConversion() {\n callback(this.options.afterTickToLabelConversion, [this]);\n }\n beforeCalculateLabelRotation() {\n callback(this.options.beforeCalculateLabelRotation, [this]);\n }\n calculateLabelRotation() {\n const options = this.options;\n const tickOpts = options.ticks;\n const numTicks = this.ticks.length;\n const minRotation = tickOpts.minRotation || 0;\n const maxRotation = tickOpts.maxRotation;\n let labelRotation = minRotation;\n let tickWidth, maxHeight, maxLabelDiagonal;\n if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {\n this.labelRotation = minRotation;\n return;\n }\n const labelSizes = this._getLabelSizes();\n const maxLabelWidth = labelSizes.widest.width;\n const maxLabelHeight = labelSizes.highest.height;\n const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);\n tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);\n if (maxLabelWidth + 6 > tickWidth) {\n tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));\n maxHeight = this.maxHeight - getTickMarkLength(options.grid)\n\t\t\t\t- tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);\n maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);\n labelRotation = toDegrees(Math.min(\n Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)),\n Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))\n ));\n labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));\n }\n this.labelRotation = labelRotation;\n }\n afterCalculateLabelRotation() {\n callback(this.options.afterCalculateLabelRotation, [this]);\n }\n afterAutoSkip() {}\n beforeFit() {\n callback(this.options.beforeFit, [this]);\n }\n fit() {\n const minSize = {\n width: 0,\n height: 0\n };\n const {chart, options: {ticks: tickOpts, title: titleOpts, grid: gridOpts}} = this;\n const display = this._isVisible();\n const isHorizontal = this.isHorizontal();\n if (display) {\n const titleHeight = getTitleHeight(titleOpts, chart.options.font);\n if (isHorizontal) {\n minSize.width = this.maxWidth;\n minSize.height = getTickMarkLength(gridOpts) + titleHeight;\n } else {\n minSize.height = this.maxHeight;\n minSize.width = getTickMarkLength(gridOpts) + titleHeight;\n }\n if (tickOpts.display && this.ticks.length) {\n const {first, last, widest, highest} = this._getLabelSizes();\n const tickPadding = tickOpts.padding * 2;\n const angleRadians = toRadians(this.labelRotation);\n const cos = Math.cos(angleRadians);\n const sin = Math.sin(angleRadians);\n if (isHorizontal) {\n const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;\n minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);\n } else {\n const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;\n minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);\n }\n this._calculatePadding(first, last, sin, cos);\n }\n }\n this._handleMargins();\n if (isHorizontal) {\n this.width = this._length = chart.width - this._margins.left - this._margins.right;\n this.height = minSize.height;\n } else {\n this.width = minSize.width;\n this.height = this._length = chart.height - this._margins.top - this._margins.bottom;\n }\n }\n _calculatePadding(first, last, sin, cos) {\n const {ticks: {align, padding}, position} = this.options;\n const isRotated = this.labelRotation !== 0;\n const labelsBelowTicks = position !== 'top' && this.axis === 'x';\n if (this.isHorizontal()) {\n const offsetLeft = this.getPixelForTick(0) - this.left;\n const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);\n let paddingLeft = 0;\n let paddingRight = 0;\n if (isRotated) {\n if (labelsBelowTicks) {\n paddingLeft = cos * first.width;\n paddingRight = sin * last.height;\n } else {\n paddingLeft = sin * first.height;\n paddingRight = cos * last.width;\n }\n } else if (align === 'start') {\n paddingRight = last.width;\n } else if (align === 'end') {\n paddingLeft = first.width;\n } else if (align !== 'inner') {\n paddingLeft = first.width / 2;\n paddingRight = last.width / 2;\n }\n this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);\n this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);\n } else {\n let paddingTop = last.height / 2;\n let paddingBottom = first.height / 2;\n if (align === 'start') {\n paddingTop = 0;\n paddingBottom = first.height;\n } else if (align === 'end') {\n paddingTop = last.height;\n paddingBottom = 0;\n }\n this.paddingTop = paddingTop + padding;\n this.paddingBottom = paddingBottom + padding;\n }\n }\n _handleMargins() {\n if (this._margins) {\n this._margins.left = Math.max(this.paddingLeft, this._margins.left);\n this._margins.top = Math.max(this.paddingTop, this._margins.top);\n this._margins.right = Math.max(this.paddingRight, this._margins.right);\n this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);\n }\n }\n afterFit() {\n callback(this.options.afterFit, [this]);\n }\n isHorizontal() {\n const {axis, position} = this.options;\n return position === 'top' || position === 'bottom' || axis === 'x';\n }\n isFullSize() {\n return this.options.fullSize;\n }\n _convertTicksToLabels(ticks) {\n this.beforeTickToLabelConversion();\n this.generateTickLabels(ticks);\n let i, ilen;\n for (i = 0, ilen = ticks.length; i < ilen; i++) {\n if (isNullOrUndef(ticks[i].label)) {\n ticks.splice(i, 1);\n ilen--;\n i--;\n }\n }\n this.afterTickToLabelConversion();\n }\n _getLabelSizes() {\n let labelSizes = this._labelSizes;\n if (!labelSizes) {\n const sampleSize = this.options.ticks.sampleSize;\n let ticks = this.ticks;\n if (sampleSize < ticks.length) {\n ticks = sample(ticks, sampleSize);\n }\n this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length);\n }\n return labelSizes;\n }\n _computeLabelSizes(ticks, length) {\n const {ctx, _longestTextCache: caches} = this;\n const widths = [];\n const heights = [];\n let widestLabelSize = 0;\n let highestLabelSize = 0;\n let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;\n for (i = 0; i < length; ++i) {\n label = ticks[i].label;\n tickFont = this._resolveTickFontOptions(i);\n ctx.font = fontString = tickFont.string;\n cache = caches[fontString] = caches[fontString] || {data: {}, gc: []};\n lineHeight = tickFont.lineHeight;\n width = height = 0;\n if (!isNullOrUndef(label) && !isArray(label)) {\n width = _measureText(ctx, cache.data, cache.gc, width, label);\n height = lineHeight;\n } else if (isArray(label)) {\n for (j = 0, jlen = label.length; j < jlen; ++j) {\n nestedLabel = label[j];\n if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {\n width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);\n height += lineHeight;\n }\n }\n }\n widths.push(width);\n heights.push(height);\n widestLabelSize = Math.max(width, widestLabelSize);\n highestLabelSize = Math.max(height, highestLabelSize);\n }\n garbageCollect(caches, length);\n const widest = widths.indexOf(widestLabelSize);\n const highest = heights.indexOf(highestLabelSize);\n const valueAt = (idx) => ({width: widths[idx] || 0, height: heights[idx] || 0});\n return {\n first: valueAt(0),\n last: valueAt(length - 1),\n widest: valueAt(widest),\n highest: valueAt(highest),\n widths,\n heights,\n };\n }\n getLabelForValue(value) {\n return value;\n }\n getPixelForValue(value, index) {\n return NaN;\n }\n getValueForPixel(pixel) {}\n getPixelForTick(index) {\n const ticks = this.ticks;\n if (index < 0 || index > ticks.length - 1) {\n return null;\n }\n return this.getPixelForValue(ticks[index].value);\n }\n getPixelForDecimal(decimal) {\n if (this._reversePixels) {\n decimal = 1 - decimal;\n }\n const pixel = this._startPixel + decimal * this._length;\n return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);\n }\n getDecimalForPixel(pixel) {\n const decimal = (pixel - this._startPixel) / this._length;\n return this._reversePixels ? 1 - decimal : decimal;\n }\n getBasePixel() {\n return this.getPixelForValue(this.getBaseValue());\n }\n getBaseValue() {\n const {min, max} = this;\n return min < 0 && max < 0 ? max :\n min > 0 && max > 0 ? min :\n 0;\n }\n getContext(index) {\n const ticks = this.ticks || [];\n if (index >= 0 && index < ticks.length) {\n const tick = ticks[index];\n return tick.$context ||\n\t\t\t\t(tick.$context = createTickContext(this.getContext(), index, tick));\n }\n return this.$context ||\n\t\t\t(this.$context = createScaleContext(this.chart.getContext(), this));\n }\n _tickSize() {\n const optionTicks = this.options.ticks;\n const rot = toRadians(this.labelRotation);\n const cos = Math.abs(Math.cos(rot));\n const sin = Math.abs(Math.sin(rot));\n const labelSizes = this._getLabelSizes();\n const padding = optionTicks.autoSkipPadding || 0;\n const w = labelSizes ? labelSizes.widest.width + padding : 0;\n const h = labelSizes ? labelSizes.highest.height + padding : 0;\n return this.isHorizontal()\n ? h * cos > w * sin ? w / cos : h / sin\n : h * sin < w * cos ? h / cos : w / sin;\n }\n _isVisible() {\n const display = this.options.display;\n if (display !== 'auto') {\n return !!display;\n }\n return this.getMatchingVisibleMetas().length > 0;\n }\n _computeGridLineItems(chartArea) {\n const axis = this.axis;\n const chart = this.chart;\n const options = this.options;\n const {grid, position} = options;\n const offset = grid.offset;\n const isHorizontal = this.isHorizontal();\n const ticks = this.ticks;\n const ticksLength = ticks.length + (offset ? 1 : 0);\n const tl = getTickMarkLength(grid);\n const items = [];\n const borderOpts = grid.setContext(this.getContext());\n const axisWidth = borderOpts.drawBorder ? borderOpts.borderWidth : 0;\n const axisHalfWidth = axisWidth / 2;\n const alignBorderValue = function(pixel) {\n return _alignPixel(chart, pixel, axisWidth);\n };\n let borderValue, i, lineValue, alignedLineValue;\n let tx1, ty1, tx2, ty2, x1, y1, x2, y2;\n if (position === 'top') {\n borderValue = alignBorderValue(this.bottom);\n ty1 = this.bottom - tl;\n ty2 = borderValue - axisHalfWidth;\n y1 = alignBorderValue(chartArea.top) + axisHalfWidth;\n y2 = chartArea.bottom;\n } else if (position === 'bottom') {\n borderValue = alignBorderValue(this.top);\n y1 = chartArea.top;\n y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;\n ty1 = borderValue + axisHalfWidth;\n ty2 = this.top + tl;\n } else if (position === 'left') {\n borderValue = alignBorderValue(this.right);\n tx1 = this.right - tl;\n tx2 = borderValue - axisHalfWidth;\n x1 = alignBorderValue(chartArea.left) + axisHalfWidth;\n x2 = chartArea.right;\n } else if (position === 'right') {\n borderValue = alignBorderValue(this.left);\n x1 = chartArea.left;\n x2 = alignBorderValue(chartArea.right) - axisHalfWidth;\n tx1 = borderValue + axisHalfWidth;\n tx2 = this.left + tl;\n } else if (axis === 'x') {\n if (position === 'center') {\n borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);\n } else if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));\n }\n y1 = chartArea.top;\n y2 = chartArea.bottom;\n ty1 = borderValue + axisHalfWidth;\n ty2 = ty1 + tl;\n } else if (axis === 'y') {\n if (position === 'center') {\n borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);\n } else if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));\n }\n tx1 = borderValue - axisHalfWidth;\n tx2 = tx1 - tl;\n x1 = chartArea.left;\n x2 = chartArea.right;\n }\n const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);\n const step = Math.max(1, Math.ceil(ticksLength / limit));\n for (i = 0; i < ticksLength; i += step) {\n const optsAtIndex = grid.setContext(this.getContext(i));\n const lineWidth = optsAtIndex.lineWidth;\n const lineColor = optsAtIndex.color;\n const borderDash = grid.borderDash || [];\n const borderDashOffset = optsAtIndex.borderDashOffset;\n const tickWidth = optsAtIndex.tickWidth;\n const tickColor = optsAtIndex.tickColor;\n const tickBorderDash = optsAtIndex.tickBorderDash || [];\n const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;\n lineValue = getPixelForGridLine(this, i, offset);\n if (lineValue === undefined) {\n continue;\n }\n alignedLineValue = _alignPixel(chart, lineValue, lineWidth);\n if (isHorizontal) {\n tx1 = tx2 = x1 = x2 = alignedLineValue;\n } else {\n ty1 = ty2 = y1 = y2 = alignedLineValue;\n }\n items.push({\n tx1,\n ty1,\n tx2,\n ty2,\n x1,\n y1,\n x2,\n y2,\n width: lineWidth,\n color: lineColor,\n borderDash,\n borderDashOffset,\n tickWidth,\n tickColor,\n tickBorderDash,\n tickBorderDashOffset,\n });\n }\n this._ticksLength = ticksLength;\n this._borderValue = borderValue;\n return items;\n }\n _computeLabelItems(chartArea) {\n const axis = this.axis;\n const options = this.options;\n const {position, ticks: optionTicks} = options;\n const isHorizontal = this.isHorizontal();\n const ticks = this.ticks;\n const {align, crossAlign, padding, mirror} = optionTicks;\n const tl = getTickMarkLength(options.grid);\n const tickAndPadding = tl + padding;\n const hTickAndPadding = mirror ? -padding : tickAndPadding;\n const rotation = -toRadians(this.labelRotation);\n const items = [];\n let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset;\n let textBaseline = 'middle';\n if (position === 'top') {\n y = this.bottom - hTickAndPadding;\n textAlign = this._getXAxisLabelAlignment();\n } else if (position === 'bottom') {\n y = this.top + hTickAndPadding;\n textAlign = this._getXAxisLabelAlignment();\n } else if (position === 'left') {\n const ret = this._getYAxisLabelAlignment(tl);\n textAlign = ret.textAlign;\n x = ret.x;\n } else if (position === 'right') {\n const ret = this._getYAxisLabelAlignment(tl);\n textAlign = ret.textAlign;\n x = ret.x;\n } else if (axis === 'x') {\n if (position === 'center') {\n y = ((chartArea.top + chartArea.bottom) / 2) + tickAndPadding;\n } else if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n y = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;\n }\n textAlign = this._getXAxisLabelAlignment();\n } else if (axis === 'y') {\n if (position === 'center') {\n x = ((chartArea.left + chartArea.right) / 2) - tickAndPadding;\n } else if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n x = this.chart.scales[positionAxisID].getPixelForValue(value);\n }\n textAlign = this._getYAxisLabelAlignment(tl).textAlign;\n }\n if (axis === 'y') {\n if (align === 'start') {\n textBaseline = 'top';\n } else if (align === 'end') {\n textBaseline = 'bottom';\n }\n }\n const labelSizes = this._getLabelSizes();\n for (i = 0, ilen = ticks.length; i < ilen; ++i) {\n tick = ticks[i];\n label = tick.label;\n const optsAtIndex = optionTicks.setContext(this.getContext(i));\n pixel = this.getPixelForTick(i) + optionTicks.labelOffset;\n font = this._resolveTickFontOptions(i);\n lineHeight = font.lineHeight;\n lineCount = isArray(label) ? label.length : 1;\n const halfCount = lineCount / 2;\n const color = optsAtIndex.color;\n const strokeColor = optsAtIndex.textStrokeColor;\n const strokeWidth = optsAtIndex.textStrokeWidth;\n let tickTextAlign = textAlign;\n if (isHorizontal) {\n x = pixel;\n if (textAlign === 'inner') {\n if (i === ilen - 1) {\n tickTextAlign = !this.options.reverse ? 'right' : 'left';\n } else if (i === 0) {\n tickTextAlign = !this.options.reverse ? 'left' : 'right';\n } else {\n tickTextAlign = 'center';\n }\n }\n if (position === 'top') {\n if (crossAlign === 'near' || rotation !== 0) {\n textOffset = -lineCount * lineHeight + lineHeight / 2;\n } else if (crossAlign === 'center') {\n textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;\n } else {\n textOffset = -labelSizes.highest.height + lineHeight / 2;\n }\n } else {\n if (crossAlign === 'near' || rotation !== 0) {\n textOffset = lineHeight / 2;\n } else if (crossAlign === 'center') {\n textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;\n } else {\n textOffset = labelSizes.highest.height - lineCount * lineHeight;\n }\n }\n if (mirror) {\n textOffset *= -1;\n }\n } else {\n y = pixel;\n textOffset = (1 - lineCount) * lineHeight / 2;\n }\n let backdrop;\n if (optsAtIndex.showLabelBackdrop) {\n const labelPadding = toPadding(optsAtIndex.backdropPadding);\n const height = labelSizes.heights[i];\n const width = labelSizes.widths[i];\n let top = y + textOffset - labelPadding.top;\n let left = x - labelPadding.left;\n switch (textBaseline) {\n case 'middle':\n top -= height / 2;\n break;\n case 'bottom':\n top -= height;\n break;\n }\n switch (textAlign) {\n case 'center':\n left -= width / 2;\n break;\n case 'right':\n left -= width;\n break;\n }\n backdrop = {\n left,\n top,\n width: width + labelPadding.width,\n height: height + labelPadding.height,\n color: optsAtIndex.backdropColor,\n };\n }\n items.push({\n rotation,\n label,\n font,\n color,\n strokeColor,\n strokeWidth,\n textOffset,\n textAlign: tickTextAlign,\n textBaseline,\n translation: [x, y],\n backdrop,\n });\n }\n return items;\n }\n _getXAxisLabelAlignment() {\n const {position, ticks} = this.options;\n const rotation = -toRadians(this.labelRotation);\n if (rotation) {\n return position === 'top' ? 'left' : 'right';\n }\n let align = 'center';\n if (ticks.align === 'start') {\n align = 'left';\n } else if (ticks.align === 'end') {\n align = 'right';\n } else if (ticks.align === 'inner') {\n align = 'inner';\n }\n return align;\n }\n _getYAxisLabelAlignment(tl) {\n const {position, ticks: {crossAlign, mirror, padding}} = this.options;\n const labelSizes = this._getLabelSizes();\n const tickAndPadding = tl + padding;\n const widest = labelSizes.widest.width;\n let textAlign;\n let x;\n if (position === 'left') {\n if (mirror) {\n x = this.right + padding;\n if (crossAlign === 'near') {\n textAlign = 'left';\n } else if (crossAlign === 'center') {\n textAlign = 'center';\n x += (widest / 2);\n } else {\n textAlign = 'right';\n x += widest;\n }\n } else {\n x = this.right - tickAndPadding;\n if (crossAlign === 'near') {\n textAlign = 'right';\n } else if (crossAlign === 'center') {\n textAlign = 'center';\n x -= (widest / 2);\n } else {\n textAlign = 'left';\n x = this.left;\n }\n }\n } else if (position === 'right') {\n if (mirror) {\n x = this.left + padding;\n if (crossAlign === 'near') {\n textAlign = 'right';\n } else if (crossAlign === 'center') {\n textAlign = 'center';\n x -= (widest / 2);\n } else {\n textAlign = 'left';\n x -= widest;\n }\n } else {\n x = this.left + tickAndPadding;\n if (crossAlign === 'near') {\n textAlign = 'left';\n } else if (crossAlign === 'center') {\n textAlign = 'center';\n x += widest / 2;\n } else {\n textAlign = 'right';\n x = this.right;\n }\n }\n } else {\n textAlign = 'right';\n }\n return {textAlign, x};\n }\n _computeLabelArea() {\n if (this.options.ticks.mirror) {\n return;\n }\n const chart = this.chart;\n const position = this.options.position;\n if (position === 'left' || position === 'right') {\n return {top: 0, left: this.left, bottom: chart.height, right: this.right};\n } if (position === 'top' || position === 'bottom') {\n return {top: this.top, left: 0, bottom: this.bottom, right: chart.width};\n }\n }\n drawBackground() {\n const {ctx, options: {backgroundColor}, left, top, width, height} = this;\n if (backgroundColor) {\n ctx.save();\n ctx.fillStyle = backgroundColor;\n ctx.fillRect(left, top, width, height);\n ctx.restore();\n }\n }\n getLineWidthForValue(value) {\n const grid = this.options.grid;\n if (!this._isVisible() || !grid.display) {\n return 0;\n }\n const ticks = this.ticks;\n const index = ticks.findIndex(t => t.value === value);\n if (index >= 0) {\n const opts = grid.setContext(this.getContext(index));\n return opts.lineWidth;\n }\n return 0;\n }\n drawGrid(chartArea) {\n const grid = this.options.grid;\n const ctx = this.ctx;\n const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));\n let i, ilen;\n const drawLine = (p1, p2, style) => {\n if (!style.width || !style.color) {\n return;\n }\n ctx.save();\n ctx.lineWidth = style.width;\n ctx.strokeStyle = style.color;\n ctx.setLineDash(style.borderDash || []);\n ctx.lineDashOffset = style.borderDashOffset;\n ctx.beginPath();\n ctx.moveTo(p1.x, p1.y);\n ctx.lineTo(p2.x, p2.y);\n ctx.stroke();\n ctx.restore();\n };\n if (grid.display) {\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n const item = items[i];\n if (grid.drawOnChartArea) {\n drawLine(\n {x: item.x1, y: item.y1},\n {x: item.x2, y: item.y2},\n item\n );\n }\n if (grid.drawTicks) {\n drawLine(\n {x: item.tx1, y: item.ty1},\n {x: item.tx2, y: item.ty2},\n {\n color: item.tickColor,\n width: item.tickWidth,\n borderDash: item.tickBorderDash,\n borderDashOffset: item.tickBorderDashOffset\n }\n );\n }\n }\n }\n }\n drawBorder() {\n const {chart, ctx, options: {grid}} = this;\n const borderOpts = grid.setContext(this.getContext());\n const axisWidth = grid.drawBorder ? borderOpts.borderWidth : 0;\n if (!axisWidth) {\n return;\n }\n const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;\n const borderValue = this._borderValue;\n let x1, x2, y1, y2;\n if (this.isHorizontal()) {\n x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;\n x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;\n y1 = y2 = borderValue;\n } else {\n y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;\n y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;\n x1 = x2 = borderValue;\n }\n ctx.save();\n ctx.lineWidth = borderOpts.borderWidth;\n ctx.strokeStyle = borderOpts.borderColor;\n ctx.beginPath();\n ctx.moveTo(x1, y1);\n ctx.lineTo(x2, y2);\n ctx.stroke();\n ctx.restore();\n }\n drawLabels(chartArea) {\n const optionTicks = this.options.ticks;\n if (!optionTicks.display) {\n return;\n }\n const ctx = this.ctx;\n const area = this._computeLabelArea();\n if (area) {\n clipArea(ctx, area);\n }\n const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));\n let i, ilen;\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n const item = items[i];\n const tickFont = item.font;\n const label = item.label;\n if (item.backdrop) {\n ctx.fillStyle = item.backdrop.color;\n ctx.fillRect(item.backdrop.left, item.backdrop.top, item.backdrop.width, item.backdrop.height);\n }\n let y = item.textOffset;\n renderText(ctx, label, 0, y, tickFont, item);\n }\n if (area) {\n unclipArea(ctx);\n }\n }\n drawTitle() {\n const {ctx, options: {position, title, reverse}} = this;\n if (!title.display) {\n return;\n }\n const font = toFont(title.font);\n const padding = toPadding(title.padding);\n const align = title.align;\n let offset = font.lineHeight / 2;\n if (position === 'bottom' || position === 'center' || isObject(position)) {\n offset += padding.bottom;\n if (isArray(title.text)) {\n offset += font.lineHeight * (title.text.length - 1);\n }\n } else {\n offset += padding.top;\n }\n const {titleX, titleY, maxWidth, rotation} = titleArgs(this, offset, position, align);\n renderText(ctx, title.text, 0, 0, font, {\n color: title.color,\n maxWidth,\n rotation,\n textAlign: titleAlign(align, position, reverse),\n textBaseline: 'middle',\n translation: [titleX, titleY],\n });\n }\n draw(chartArea) {\n if (!this._isVisible()) {\n return;\n }\n this.drawBackground();\n this.drawGrid(chartArea);\n this.drawBorder();\n this.drawTitle();\n this.drawLabels(chartArea);\n }\n _layers() {\n const opts = this.options;\n const tz = opts.ticks && opts.ticks.z || 0;\n const gz = valueOrDefault(opts.grid && opts.grid.z, -1);\n if (!this._isVisible() || this.draw !== Scale.prototype.draw) {\n return [{\n z: tz,\n draw: (chartArea) => {\n this.draw(chartArea);\n }\n }];\n }\n return [{\n z: gz,\n draw: (chartArea) => {\n this.drawBackground();\n this.drawGrid(chartArea);\n this.drawTitle();\n }\n }, {\n z: gz + 1,\n draw: () => {\n this.drawBorder();\n }\n }, {\n z: tz,\n draw: (chartArea) => {\n this.drawLabels(chartArea);\n }\n }];\n }\n getMatchingVisibleMetas(type) {\n const metas = this.chart.getSortedVisibleDatasetMetas();\n const axisID = this.axis + 'AxisID';\n const result = [];\n let i, ilen;\n for (i = 0, ilen = metas.length; i < ilen; ++i) {\n const meta = metas[i];\n if (meta[axisID] === this.id && (!type || meta.type === type)) {\n result.push(meta);\n }\n }\n return result;\n }\n _resolveTickFontOptions(index) {\n const opts = this.options.ticks.setContext(this.getContext(index));\n return toFont(opts.font);\n }\n _maxDigits() {\n const fontSize = this._resolveTickFontOptions(0).lineHeight;\n return (this.isHorizontal() ? this.width : this.height) / fontSize;\n }\n}\n\nclass TypedRegistry {\n constructor(type, scope, override) {\n this.type = type;\n this.scope = scope;\n this.override = override;\n this.items = Object.create(null);\n }\n isForType(type) {\n return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);\n }\n register(item) {\n const proto = Object.getPrototypeOf(item);\n let parentScope;\n if (isIChartComponent(proto)) {\n parentScope = this.register(proto);\n }\n const items = this.items;\n const id = item.id;\n const scope = this.scope + '.' + id;\n if (!id) {\n throw new Error('class does not have id: ' + item);\n }\n if (id in items) {\n return scope;\n }\n items[id] = item;\n registerDefaults(item, scope, parentScope);\n if (this.override) {\n defaults.override(item.id, item.overrides);\n }\n return scope;\n }\n get(id) {\n return this.items[id];\n }\n unregister(item) {\n const items = this.items;\n const id = item.id;\n const scope = this.scope;\n if (id in items) {\n delete items[id];\n }\n if (scope && id in defaults[scope]) {\n delete defaults[scope][id];\n if (this.override) {\n delete overrides[id];\n }\n }\n }\n}\nfunction registerDefaults(item, scope, parentScope) {\n const itemDefaults = merge(Object.create(null), [\n parentScope ? defaults.get(parentScope) : {},\n defaults.get(scope),\n item.defaults\n ]);\n defaults.set(scope, itemDefaults);\n if (item.defaultRoutes) {\n routeDefaults(scope, item.defaultRoutes);\n }\n if (item.descriptors) {\n defaults.describe(scope, item.descriptors);\n }\n}\nfunction routeDefaults(scope, routes) {\n Object.keys(routes).forEach(property => {\n const propertyParts = property.split('.');\n const sourceName = propertyParts.pop();\n const sourceScope = [scope].concat(propertyParts).join('.');\n const parts = routes[property].split('.');\n const targetName = parts.pop();\n const targetScope = parts.join('.');\n defaults.route(sourceScope, sourceName, targetScope, targetName);\n });\n}\nfunction isIChartComponent(proto) {\n return 'id' in proto && 'defaults' in proto;\n}\n\nclass Registry {\n constructor() {\n this.controllers = new TypedRegistry(DatasetController, 'datasets', true);\n this.elements = new TypedRegistry(Element, 'elements');\n this.plugins = new TypedRegistry(Object, 'plugins');\n this.scales = new TypedRegistry(Scale, 'scales');\n this._typedRegistries = [this.controllers, this.scales, this.elements];\n }\n add(...args) {\n this._each('register', args);\n }\n remove(...args) {\n this._each('unregister', args);\n }\n addControllers(...args) {\n this._each('register', args, this.controllers);\n }\n addElements(...args) {\n this._each('register', args, this.elements);\n }\n addPlugins(...args) {\n this._each('register', args, this.plugins);\n }\n addScales(...args) {\n this._each('register', args, this.scales);\n }\n getController(id) {\n return this._get(id, this.controllers, 'controller');\n }\n getElement(id) {\n return this._get(id, this.elements, 'element');\n }\n getPlugin(id) {\n return this._get(id, this.plugins, 'plugin');\n }\n getScale(id) {\n return this._get(id, this.scales, 'scale');\n }\n removeControllers(...args) {\n this._each('unregister', args, this.controllers);\n }\n removeElements(...args) {\n this._each('unregister', args, this.elements);\n }\n removePlugins(...args) {\n this._each('unregister', args, this.plugins);\n }\n removeScales(...args) {\n this._each('unregister', args, this.scales);\n }\n _each(method, args, typedRegistry) {\n [...args].forEach(arg => {\n const reg = typedRegistry || this._getRegistryForType(arg);\n if (typedRegistry || reg.isForType(arg) || (reg === this.plugins && arg.id)) {\n this._exec(method, reg, arg);\n } else {\n each(arg, item => {\n const itemReg = typedRegistry || this._getRegistryForType(item);\n this._exec(method, itemReg, item);\n });\n }\n });\n }\n _exec(method, registry, component) {\n const camelMethod = _capitalize(method);\n callback(component['before' + camelMethod], [], component);\n registry[method](component);\n callback(component['after' + camelMethod], [], component);\n }\n _getRegistryForType(type) {\n for (let i = 0; i < this._typedRegistries.length; i++) {\n const reg = this._typedRegistries[i];\n if (reg.isForType(type)) {\n return reg;\n }\n }\n return this.plugins;\n }\n _get(id, typedRegistry, type) {\n const item = typedRegistry.get(id);\n if (item === undefined) {\n throw new Error('\"' + id + '\" is not a registered ' + type + '.');\n }\n return item;\n }\n}\nvar registry = new Registry();\n\nclass PluginService {\n constructor() {\n this._init = [];\n }\n notify(chart, hook, args, filter) {\n if (hook === 'beforeInit') {\n this._init = this._createDescriptors(chart, true);\n this._notify(this._init, chart, 'install');\n }\n const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart);\n const result = this._notify(descriptors, chart, hook, args);\n if (hook === 'afterDestroy') {\n this._notify(descriptors, chart, 'stop');\n this._notify(this._init, chart, 'uninstall');\n }\n return result;\n }\n _notify(descriptors, chart, hook, args) {\n args = args || {};\n for (const descriptor of descriptors) {\n const plugin = descriptor.plugin;\n const method = plugin[hook];\n const params = [chart, args, descriptor.options];\n if (callback(method, params, plugin) === false && args.cancelable) {\n return false;\n }\n }\n return true;\n }\n invalidate() {\n if (!isNullOrUndef(this._cache)) {\n this._oldCache = this._cache;\n this._cache = undefined;\n }\n }\n _descriptors(chart) {\n if (this._cache) {\n return this._cache;\n }\n const descriptors = this._cache = this._createDescriptors(chart);\n this._notifyStateChanges(chart);\n return descriptors;\n }\n _createDescriptors(chart, all) {\n const config = chart && chart.config;\n const options = valueOrDefault(config.options && config.options.plugins, {});\n const plugins = allPlugins(config);\n return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);\n }\n _notifyStateChanges(chart) {\n const previousDescriptors = this._oldCache || [];\n const descriptors = this._cache;\n const diff = (a, b) => a.filter(x => !b.some(y => x.plugin.id === y.plugin.id));\n this._notify(diff(previousDescriptors, descriptors), chart, 'stop');\n this._notify(diff(descriptors, previousDescriptors), chart, 'start');\n }\n}\nfunction allPlugins(config) {\n const plugins = [];\n const keys = Object.keys(registry.plugins.items);\n for (let i = 0; i < keys.length; i++) {\n plugins.push(registry.getPlugin(keys[i]));\n }\n const local = config.plugins || [];\n for (let i = 0; i < local.length; i++) {\n const plugin = local[i];\n if (plugins.indexOf(plugin) === -1) {\n plugins.push(plugin);\n }\n }\n return plugins;\n}\nfunction getOpts(options, all) {\n if (!all && options === false) {\n return null;\n }\n if (options === true) {\n return {};\n }\n return options;\n}\nfunction createDescriptors(chart, plugins, options, all) {\n const result = [];\n const context = chart.getContext();\n for (let i = 0; i < plugins.length; i++) {\n const plugin = plugins[i];\n const id = plugin.id;\n const opts = getOpts(options[id], all);\n if (opts === null) {\n continue;\n }\n result.push({\n plugin,\n options: pluginOpts(chart.config, plugin, opts, context)\n });\n }\n return result;\n}\nfunction pluginOpts(config, plugin, opts, context) {\n const keys = config.pluginScopeKeys(plugin);\n const scopes = config.getOptionScopes(opts, keys);\n return config.createResolver(scopes, context, [''], {scriptable: false, indexable: false, allKeys: true});\n}\n\nfunction getIndexAxis(type, options) {\n const datasetDefaults = defaults.datasets[type] || {};\n const datasetOptions = (options.datasets || {})[type] || {};\n return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x';\n}\nfunction getAxisFromDefaultScaleID(id, indexAxis) {\n let axis = id;\n if (id === '_index_') {\n axis = indexAxis;\n } else if (id === '_value_') {\n axis = indexAxis === 'x' ? 'y' : 'x';\n }\n return axis;\n}\nfunction getDefaultScaleIDFromAxis(axis, indexAxis) {\n return axis === indexAxis ? '_index_' : '_value_';\n}\nfunction axisFromPosition(position) {\n if (position === 'top' || position === 'bottom') {\n return 'x';\n }\n if (position === 'left' || position === 'right') {\n return 'y';\n }\n}\nfunction determineAxis(id, scaleOptions) {\n if (id === 'x' || id === 'y') {\n return id;\n }\n return scaleOptions.axis || axisFromPosition(scaleOptions.position) || id.charAt(0).toLowerCase();\n}\nfunction mergeScaleConfig(config, options) {\n const chartDefaults = overrides[config.type] || {scales: {}};\n const configScales = options.scales || {};\n const chartIndexAxis = getIndexAxis(config.type, options);\n const firstIDs = Object.create(null);\n const scales = Object.create(null);\n Object.keys(configScales).forEach(id => {\n const scaleConf = configScales[id];\n if (!isObject(scaleConf)) {\n return console.error(`Invalid scale configuration for scale: ${id}`);\n }\n if (scaleConf._proxy) {\n return console.warn(`Ignoring resolver passed as options for scale: ${id}`);\n }\n const axis = determineAxis(id, scaleConf);\n const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);\n const defaultScaleOptions = chartDefaults.scales || {};\n firstIDs[axis] = firstIDs[axis] || id;\n scales[id] = mergeIf(Object.create(null), [{axis}, scaleConf, defaultScaleOptions[axis], defaultScaleOptions[defaultId]]);\n });\n config.data.datasets.forEach(dataset => {\n const type = dataset.type || config.type;\n const indexAxis = dataset.indexAxis || getIndexAxis(type, options);\n const datasetDefaults = overrides[type] || {};\n const defaultScaleOptions = datasetDefaults.scales || {};\n Object.keys(defaultScaleOptions).forEach(defaultID => {\n const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);\n const id = dataset[axis + 'AxisID'] || firstIDs[axis] || axis;\n scales[id] = scales[id] || Object.create(null);\n mergeIf(scales[id], [{axis}, configScales[id], defaultScaleOptions[defaultID]]);\n });\n });\n Object.keys(scales).forEach(key => {\n const scale = scales[key];\n mergeIf(scale, [defaults.scales[scale.type], defaults.scale]);\n });\n return scales;\n}\nfunction initOptions(config) {\n const options = config.options || (config.options = {});\n options.plugins = valueOrDefault(options.plugins, {});\n options.scales = mergeScaleConfig(config, options);\n}\nfunction initData(data) {\n data = data || {};\n data.datasets = data.datasets || [];\n data.labels = data.labels || [];\n return data;\n}\nfunction initConfig(config) {\n config = config || {};\n config.data = initData(config.data);\n initOptions(config);\n return config;\n}\nconst keyCache = new Map();\nconst keysCached = new Set();\nfunction cachedKeys(cacheKey, generate) {\n let keys = keyCache.get(cacheKey);\n if (!keys) {\n keys = generate();\n keyCache.set(cacheKey, keys);\n keysCached.add(keys);\n }\n return keys;\n}\nconst addIfFound = (set, obj, key) => {\n const opts = resolveObjectKey(obj, key);\n if (opts !== undefined) {\n set.add(opts);\n }\n};\nclass Config {\n constructor(config) {\n this._config = initConfig(config);\n this._scopeCache = new Map();\n this._resolverCache = new Map();\n }\n get platform() {\n return this._config.platform;\n }\n get type() {\n return this._config.type;\n }\n set type(type) {\n this._config.type = type;\n }\n get data() {\n return this._config.data;\n }\n set data(data) {\n this._config.data = initData(data);\n }\n get options() {\n return this._config.options;\n }\n set options(options) {\n this._config.options = options;\n }\n get plugins() {\n return this._config.plugins;\n }\n update() {\n const config = this._config;\n this.clearCache();\n initOptions(config);\n }\n clearCache() {\n this._scopeCache.clear();\n this._resolverCache.clear();\n }\n datasetScopeKeys(datasetType) {\n return cachedKeys(datasetType,\n () => [[\n `datasets.${datasetType}`,\n ''\n ]]);\n }\n datasetAnimationScopeKeys(datasetType, transition) {\n return cachedKeys(`${datasetType}.transition.${transition}`,\n () => [\n [\n `datasets.${datasetType}.transitions.${transition}`,\n `transitions.${transition}`,\n ],\n [\n `datasets.${datasetType}`,\n ''\n ]\n ]);\n }\n datasetElementScopeKeys(datasetType, elementType) {\n return cachedKeys(`${datasetType}-${elementType}`,\n () => [[\n `datasets.${datasetType}.elements.${elementType}`,\n `datasets.${datasetType}`,\n `elements.${elementType}`,\n ''\n ]]);\n }\n pluginScopeKeys(plugin) {\n const id = plugin.id;\n const type = this.type;\n return cachedKeys(`${type}-plugin-${id}`,\n () => [[\n `plugins.${id}`,\n ...plugin.additionalOptionScopes || [],\n ]]);\n }\n _cachedScopes(mainScope, resetCache) {\n const _scopeCache = this._scopeCache;\n let cache = _scopeCache.get(mainScope);\n if (!cache || resetCache) {\n cache = new Map();\n _scopeCache.set(mainScope, cache);\n }\n return cache;\n }\n getOptionScopes(mainScope, keyLists, resetCache) {\n const {options, type} = this;\n const cache = this._cachedScopes(mainScope, resetCache);\n const cached = cache.get(keyLists);\n if (cached) {\n return cached;\n }\n const scopes = new Set();\n keyLists.forEach(keys => {\n if (mainScope) {\n scopes.add(mainScope);\n keys.forEach(key => addIfFound(scopes, mainScope, key));\n }\n keys.forEach(key => addIfFound(scopes, options, key));\n keys.forEach(key => addIfFound(scopes, overrides[type] || {}, key));\n keys.forEach(key => addIfFound(scopes, defaults, key));\n keys.forEach(key => addIfFound(scopes, descriptors, key));\n });\n const array = Array.from(scopes);\n if (array.length === 0) {\n array.push(Object.create(null));\n }\n if (keysCached.has(keyLists)) {\n cache.set(keyLists, array);\n }\n return array;\n }\n chartOptionScopes() {\n const {options, type} = this;\n return [\n options,\n overrides[type] || {},\n defaults.datasets[type] || {},\n {type},\n defaults,\n descriptors\n ];\n }\n resolveNamedOptions(scopes, names, context, prefixes = ['']) {\n const result = {$shared: true};\n const {resolver, subPrefixes} = getResolver(this._resolverCache, scopes, prefixes);\n let options = resolver;\n if (needContext(resolver, names)) {\n result.$shared = false;\n context = isFunction(context) ? context() : context;\n const subResolver = this.createResolver(scopes, context, subPrefixes);\n options = _attachContext(resolver, context, subResolver);\n }\n for (const prop of names) {\n result[prop] = options[prop];\n }\n return result;\n }\n createResolver(scopes, context, prefixes = [''], descriptorDefaults) {\n const {resolver} = getResolver(this._resolverCache, scopes, prefixes);\n return isObject(context)\n ? _attachContext(resolver, context, undefined, descriptorDefaults)\n : resolver;\n }\n}\nfunction getResolver(resolverCache, scopes, prefixes) {\n let cache = resolverCache.get(scopes);\n if (!cache) {\n cache = new Map();\n resolverCache.set(scopes, cache);\n }\n const cacheKey = prefixes.join();\n let cached = cache.get(cacheKey);\n if (!cached) {\n const resolver = _createResolver(scopes, prefixes);\n cached = {\n resolver,\n subPrefixes: prefixes.filter(p => !p.toLowerCase().includes('hover'))\n };\n cache.set(cacheKey, cached);\n }\n return cached;\n}\nconst hasFunction = value => isObject(value)\n && Object.getOwnPropertyNames(value).reduce((acc, key) => acc || isFunction(value[key]), false);\nfunction needContext(proxy, names) {\n const {isScriptable, isIndexable} = _descriptors(proxy);\n for (const prop of names) {\n const scriptable = isScriptable(prop);\n const indexable = isIndexable(prop);\n const value = (indexable || scriptable) && proxy[prop];\n if ((scriptable && (isFunction(value) || hasFunction(value)))\n || (indexable && isArray(value))) {\n return true;\n }\n }\n return false;\n}\n\nvar version = \"3.8.0\";\n\nconst KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea'];\nfunction positionIsHorizontal(position, axis) {\n return position === 'top' || position === 'bottom' || (KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x');\n}\nfunction compare2Level(l1, l2) {\n return function(a, b) {\n return a[l1] === b[l1]\n ? a[l2] - b[l2]\n : a[l1] - b[l1];\n };\n}\nfunction onAnimationsComplete(context) {\n const chart = context.chart;\n const animationOptions = chart.options.animation;\n chart.notifyPlugins('afterRender');\n callback(animationOptions && animationOptions.onComplete, [context], chart);\n}\nfunction onAnimationProgress(context) {\n const chart = context.chart;\n const animationOptions = chart.options.animation;\n callback(animationOptions && animationOptions.onProgress, [context], chart);\n}\nfunction getCanvas(item) {\n if (_isDomSupported() && typeof item === 'string') {\n item = document.getElementById(item);\n } else if (item && item.length) {\n item = item[0];\n }\n if (item && item.canvas) {\n item = item.canvas;\n }\n return item;\n}\nconst instances = {};\nconst getChart = (key) => {\n const canvas = getCanvas(key);\n return Object.values(instances).filter((c) => c.canvas === canvas).pop();\n};\nfunction moveNumericKeys(obj, start, move) {\n const keys = Object.keys(obj);\n for (const key of keys) {\n const intKey = +key;\n if (intKey >= start) {\n const value = obj[key];\n delete obj[key];\n if (move > 0 || intKey > start) {\n obj[intKey + move] = value;\n }\n }\n }\n}\nfunction determineLastEvent(e, lastEvent, inChartArea, isClick) {\n if (!inChartArea || e.type === 'mouseout') {\n return null;\n }\n if (isClick) {\n return lastEvent;\n }\n return e;\n}\nclass Chart {\n constructor(item, userConfig) {\n const config = this.config = new Config(userConfig);\n const initialCanvas = getCanvas(item);\n const existingChart = getChart(initialCanvas);\n if (existingChart) {\n throw new Error(\n 'Canvas is already in use. Chart with ID \\'' + existingChart.id + '\\'' +\n\t\t\t\t' must be destroyed before the canvas can be reused.'\n );\n }\n const options = config.createResolver(config.chartOptionScopes(), this.getContext());\n this.platform = new (config.platform || _detectPlatform(initialCanvas))();\n this.platform.updateConfig(config);\n const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);\n const canvas = context && context.canvas;\n const height = canvas && canvas.height;\n const width = canvas && canvas.width;\n this.id = uid();\n this.ctx = context;\n this.canvas = canvas;\n this.width = width;\n this.height = height;\n this._options = options;\n this._aspectRatio = this.aspectRatio;\n this._layers = [];\n this._metasets = [];\n this._stacks = undefined;\n this.boxes = [];\n this.currentDevicePixelRatio = undefined;\n this.chartArea = undefined;\n this._active = [];\n this._lastEvent = undefined;\n this._listeners = {};\n this._responsiveListeners = undefined;\n this._sortedMetasets = [];\n this.scales = {};\n this._plugins = new PluginService();\n this.$proxies = {};\n this._hiddenIndices = {};\n this.attached = false;\n this._animationsDisabled = undefined;\n this.$context = undefined;\n this._doResize = debounce(mode => this.update(mode), options.resizeDelay || 0);\n this._dataChanges = [];\n instances[this.id] = this;\n if (!context || !canvas) {\n console.error(\"Failed to create chart: can't acquire context from the given item\");\n return;\n }\n animator.listen(this, 'complete', onAnimationsComplete);\n animator.listen(this, 'progress', onAnimationProgress);\n this._initialize();\n if (this.attached) {\n this.update();\n }\n }\n get aspectRatio() {\n const {options: {aspectRatio, maintainAspectRatio}, width, height, _aspectRatio} = this;\n if (!isNullOrUndef(aspectRatio)) {\n return aspectRatio;\n }\n if (maintainAspectRatio && _aspectRatio) {\n return _aspectRatio;\n }\n return height ? width / height : null;\n }\n get data() {\n return this.config.data;\n }\n set data(data) {\n this.config.data = data;\n }\n get options() {\n return this._options;\n }\n set options(options) {\n this.config.options = options;\n }\n _initialize() {\n this.notifyPlugins('beforeInit');\n if (this.options.responsive) {\n this.resize();\n } else {\n retinaScale(this, this.options.devicePixelRatio);\n }\n this.bindEvents();\n this.notifyPlugins('afterInit');\n return this;\n }\n clear() {\n clearCanvas(this.canvas, this.ctx);\n return this;\n }\n stop() {\n animator.stop(this);\n return this;\n }\n resize(width, height) {\n if (!animator.running(this)) {\n this._resize(width, height);\n } else {\n this._resizeBeforeDraw = {width, height};\n }\n }\n _resize(width, height) {\n const options = this.options;\n const canvas = this.canvas;\n const aspectRatio = options.maintainAspectRatio && this.aspectRatio;\n const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);\n const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();\n const mode = this.width ? 'resize' : 'attach';\n this.width = newSize.width;\n this.height = newSize.height;\n this._aspectRatio = this.aspectRatio;\n if (!retinaScale(this, newRatio, true)) {\n return;\n }\n this.notifyPlugins('resize', {size: newSize});\n callback(options.onResize, [this, newSize], this);\n if (this.attached) {\n if (this._doResize(mode)) {\n this.render();\n }\n }\n }\n ensureScalesHaveIDs() {\n const options = this.options;\n const scalesOptions = options.scales || {};\n each(scalesOptions, (axisOptions, axisID) => {\n axisOptions.id = axisID;\n });\n }\n buildOrUpdateScales() {\n const options = this.options;\n const scaleOpts = options.scales;\n const scales = this.scales;\n const updated = Object.keys(scales).reduce((obj, id) => {\n obj[id] = false;\n return obj;\n }, {});\n let items = [];\n if (scaleOpts) {\n items = items.concat(\n Object.keys(scaleOpts).map((id) => {\n const scaleOptions = scaleOpts[id];\n const axis = determineAxis(id, scaleOptions);\n const isRadial = axis === 'r';\n const isHorizontal = axis === 'x';\n return {\n options: scaleOptions,\n dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left',\n dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear'\n };\n })\n );\n }\n each(items, (item) => {\n const scaleOptions = item.options;\n const id = scaleOptions.id;\n const axis = determineAxis(id, scaleOptions);\n const scaleType = valueOrDefault(scaleOptions.type, item.dtype);\n if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {\n scaleOptions.position = item.dposition;\n }\n updated[id] = true;\n let scale = null;\n if (id in scales && scales[id].type === scaleType) {\n scale = scales[id];\n } else {\n const scaleClass = registry.getScale(scaleType);\n scale = new scaleClass({\n id,\n type: scaleType,\n ctx: this.ctx,\n chart: this\n });\n scales[scale.id] = scale;\n }\n scale.init(scaleOptions, options);\n });\n each(updated, (hasUpdated, id) => {\n if (!hasUpdated) {\n delete scales[id];\n }\n });\n each(scales, (scale) => {\n layouts.configure(this, scale, scale.options);\n layouts.addBox(this, scale);\n });\n }\n _updateMetasets() {\n const metasets = this._metasets;\n const numData = this.data.datasets.length;\n const numMeta = metasets.length;\n metasets.sort((a, b) => a.index - b.index);\n if (numMeta > numData) {\n for (let i = numData; i < numMeta; ++i) {\n this._destroyDatasetMeta(i);\n }\n metasets.splice(numData, numMeta - numData);\n }\n this._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index'));\n }\n _removeUnreferencedMetasets() {\n const {_metasets: metasets, data: {datasets}} = this;\n if (metasets.length > datasets.length) {\n delete this._stacks;\n }\n metasets.forEach((meta, index) => {\n if (datasets.filter(x => x === meta._dataset).length === 0) {\n this._destroyDatasetMeta(index);\n }\n });\n }\n buildOrUpdateControllers() {\n const newControllers = [];\n const datasets = this.data.datasets;\n let i, ilen;\n this._removeUnreferencedMetasets();\n for (i = 0, ilen = datasets.length; i < ilen; i++) {\n const dataset = datasets[i];\n let meta = this.getDatasetMeta(i);\n const type = dataset.type || this.config.type;\n if (meta.type && meta.type !== type) {\n this._destroyDatasetMeta(i);\n meta = this.getDatasetMeta(i);\n }\n meta.type = type;\n meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);\n meta.order = dataset.order || 0;\n meta.index = i;\n meta.label = '' + dataset.label;\n meta.visible = this.isDatasetVisible(i);\n if (meta.controller) {\n meta.controller.updateIndex(i);\n meta.controller.linkScales();\n } else {\n const ControllerClass = registry.getController(type);\n const {datasetElementType, dataElementType} = defaults.datasets[type];\n Object.assign(ControllerClass.prototype, {\n dataElementType: registry.getElement(dataElementType),\n datasetElementType: datasetElementType && registry.getElement(datasetElementType)\n });\n meta.controller = new ControllerClass(this, i);\n newControllers.push(meta.controller);\n }\n }\n this._updateMetasets();\n return newControllers;\n }\n _resetElements() {\n each(this.data.datasets, (dataset, datasetIndex) => {\n this.getDatasetMeta(datasetIndex).controller.reset();\n }, this);\n }\n reset() {\n this._resetElements();\n this.notifyPlugins('reset');\n }\n update(mode) {\n const config = this.config;\n config.update();\n const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());\n const animsDisabled = this._animationsDisabled = !options.animation;\n this._updateScales();\n this._checkEventBindings();\n this._updateHiddenIndices();\n this._plugins.invalidate();\n if (this.notifyPlugins('beforeUpdate', {mode, cancelable: true}) === false) {\n return;\n }\n const newControllers = this.buildOrUpdateControllers();\n this.notifyPlugins('beforeElementsUpdate');\n let minPadding = 0;\n for (let i = 0, ilen = this.data.datasets.length; i < ilen; i++) {\n const {controller} = this.getDatasetMeta(i);\n const reset = !animsDisabled && newControllers.indexOf(controller) === -1;\n controller.buildOrUpdateElements(reset);\n minPadding = Math.max(+controller.getMaxOverflow(), minPadding);\n }\n minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;\n this._updateLayout(minPadding);\n if (!animsDisabled) {\n each(newControllers, (controller) => {\n controller.reset();\n });\n }\n this._updateDatasets(mode);\n this.notifyPlugins('afterUpdate', {mode});\n this._layers.sort(compare2Level('z', '_idx'));\n const {_active, _lastEvent} = this;\n if (_lastEvent) {\n this._eventHandler(_lastEvent, true);\n } else if (_active.length) {\n this._updateHoverStyles(_active, _active, true);\n }\n this.render();\n }\n _updateScales() {\n each(this.scales, (scale) => {\n layouts.removeBox(this, scale);\n });\n this.ensureScalesHaveIDs();\n this.buildOrUpdateScales();\n }\n _checkEventBindings() {\n const options = this.options;\n const existingEvents = new Set(Object.keys(this._listeners));\n const newEvents = new Set(options.events);\n if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {\n this.unbindEvents();\n this.bindEvents();\n }\n }\n _updateHiddenIndices() {\n const {_hiddenIndices} = this;\n const changes = this._getUniformDataChanges() || [];\n for (const {method, start, count} of changes) {\n const move = method === '_removeElements' ? -count : count;\n moveNumericKeys(_hiddenIndices, start, move);\n }\n }\n _getUniformDataChanges() {\n const _dataChanges = this._dataChanges;\n if (!_dataChanges || !_dataChanges.length) {\n return;\n }\n this._dataChanges = [];\n const datasetCount = this.data.datasets.length;\n const makeSet = (idx) => new Set(\n _dataChanges\n .filter(c => c[0] === idx)\n .map((c, i) => i + ',' + c.splice(1).join(','))\n );\n const changeSet = makeSet(0);\n for (let i = 1; i < datasetCount; i++) {\n if (!setsEqual(changeSet, makeSet(i))) {\n return;\n }\n }\n return Array.from(changeSet)\n .map(c => c.split(','))\n .map(a => ({method: a[1], start: +a[2], count: +a[3]}));\n }\n _updateLayout(minPadding) {\n if (this.notifyPlugins('beforeLayout', {cancelable: true}) === false) {\n return;\n }\n layouts.update(this, this.width, this.height, minPadding);\n const area = this.chartArea;\n const noArea = area.width <= 0 || area.height <= 0;\n this._layers = [];\n each(this.boxes, (box) => {\n if (noArea && box.position === 'chartArea') {\n return;\n }\n if (box.configure) {\n box.configure();\n }\n this._layers.push(...box._layers());\n }, this);\n this._layers.forEach((item, index) => {\n item._idx = index;\n });\n this.notifyPlugins('afterLayout');\n }\n _updateDatasets(mode) {\n if (this.notifyPlugins('beforeDatasetsUpdate', {mode, cancelable: true}) === false) {\n return;\n }\n for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n this.getDatasetMeta(i).controller.configure();\n }\n for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n this._updateDataset(i, isFunction(mode) ? mode({datasetIndex: i}) : mode);\n }\n this.notifyPlugins('afterDatasetsUpdate', {mode});\n }\n _updateDataset(index, mode) {\n const meta = this.getDatasetMeta(index);\n const args = {meta, index, mode, cancelable: true};\n if (this.notifyPlugins('beforeDatasetUpdate', args) === false) {\n return;\n }\n meta.controller._update(mode);\n args.cancelable = false;\n this.notifyPlugins('afterDatasetUpdate', args);\n }\n render() {\n if (this.notifyPlugins('beforeRender', {cancelable: true}) === false) {\n return;\n }\n if (animator.has(this)) {\n if (this.attached && !animator.running(this)) {\n animator.start(this);\n }\n } else {\n this.draw();\n onAnimationsComplete({chart: this});\n }\n }\n draw() {\n let i;\n if (this._resizeBeforeDraw) {\n const {width, height} = this._resizeBeforeDraw;\n this._resize(width, height);\n this._resizeBeforeDraw = null;\n }\n this.clear();\n if (this.width <= 0 || this.height <= 0) {\n return;\n }\n if (this.notifyPlugins('beforeDraw', {cancelable: true}) === false) {\n return;\n }\n const layers = this._layers;\n for (i = 0; i < layers.length && layers[i].z <= 0; ++i) {\n layers[i].draw(this.chartArea);\n }\n this._drawDatasets();\n for (; i < layers.length; ++i) {\n layers[i].draw(this.chartArea);\n }\n this.notifyPlugins('afterDraw');\n }\n _getSortedDatasetMetas(filterVisible) {\n const metasets = this._sortedMetasets;\n const result = [];\n let i, ilen;\n for (i = 0, ilen = metasets.length; i < ilen; ++i) {\n const meta = metasets[i];\n if (!filterVisible || meta.visible) {\n result.push(meta);\n }\n }\n return result;\n }\n getSortedVisibleDatasetMetas() {\n return this._getSortedDatasetMetas(true);\n }\n _drawDatasets() {\n if (this.notifyPlugins('beforeDatasetsDraw', {cancelable: true}) === false) {\n return;\n }\n const metasets = this.getSortedVisibleDatasetMetas();\n for (let i = metasets.length - 1; i >= 0; --i) {\n this._drawDataset(metasets[i]);\n }\n this.notifyPlugins('afterDatasetsDraw');\n }\n _drawDataset(meta) {\n const ctx = this.ctx;\n const clip = meta._clip;\n const useClip = !clip.disabled;\n const area = this.chartArea;\n const args = {\n meta,\n index: meta.index,\n cancelable: true\n };\n if (this.notifyPlugins('beforeDatasetDraw', args) === false) {\n return;\n }\n if (useClip) {\n clipArea(ctx, {\n left: clip.left === false ? 0 : area.left - clip.left,\n right: clip.right === false ? this.width : area.right + clip.right,\n top: clip.top === false ? 0 : area.top - clip.top,\n bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom\n });\n }\n meta.controller.draw();\n if (useClip) {\n unclipArea(ctx);\n }\n args.cancelable = false;\n this.notifyPlugins('afterDatasetDraw', args);\n }\n isPointInArea(point) {\n return _isPointInArea(point, this.chartArea, this._minPadding);\n }\n getElementsAtEventForMode(e, mode, options, useFinalPosition) {\n const method = Interaction.modes[mode];\n if (typeof method === 'function') {\n return method(this, e, options, useFinalPosition);\n }\n return [];\n }\n getDatasetMeta(datasetIndex) {\n const dataset = this.data.datasets[datasetIndex];\n const metasets = this._metasets;\n let meta = metasets.filter(x => x && x._dataset === dataset).pop();\n if (!meta) {\n meta = {\n type: null,\n data: [],\n dataset: null,\n controller: null,\n hidden: null,\n xAxisID: null,\n yAxisID: null,\n order: dataset && dataset.order || 0,\n index: datasetIndex,\n _dataset: dataset,\n _parsed: [],\n _sorted: false\n };\n metasets.push(meta);\n }\n return meta;\n }\n getContext() {\n return this.$context || (this.$context = createContext(null, {chart: this, type: 'chart'}));\n }\n getVisibleDatasetCount() {\n return this.getSortedVisibleDatasetMetas().length;\n }\n isDatasetVisible(datasetIndex) {\n const dataset = this.data.datasets[datasetIndex];\n if (!dataset) {\n return false;\n }\n const meta = this.getDatasetMeta(datasetIndex);\n return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden;\n }\n setDatasetVisibility(datasetIndex, visible) {\n const meta = this.getDatasetMeta(datasetIndex);\n meta.hidden = !visible;\n }\n toggleDataVisibility(index) {\n this._hiddenIndices[index] = !this._hiddenIndices[index];\n }\n getDataVisibility(index) {\n return !this._hiddenIndices[index];\n }\n _updateVisibility(datasetIndex, dataIndex, visible) {\n const mode = visible ? 'show' : 'hide';\n const meta = this.getDatasetMeta(datasetIndex);\n const anims = meta.controller._resolveAnimations(undefined, mode);\n if (defined(dataIndex)) {\n meta.data[dataIndex].hidden = !visible;\n this.update();\n } else {\n this.setDatasetVisibility(datasetIndex, visible);\n anims.update(meta, {visible});\n this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : undefined);\n }\n }\n hide(datasetIndex, dataIndex) {\n this._updateVisibility(datasetIndex, dataIndex, false);\n }\n show(datasetIndex, dataIndex) {\n this._updateVisibility(datasetIndex, dataIndex, true);\n }\n _destroyDatasetMeta(datasetIndex) {\n const meta = this._metasets[datasetIndex];\n if (meta && meta.controller) {\n meta.controller._destroy();\n }\n delete this._metasets[datasetIndex];\n }\n _stop() {\n let i, ilen;\n this.stop();\n animator.remove(this);\n for (i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n this._destroyDatasetMeta(i);\n }\n }\n destroy() {\n this.notifyPlugins('beforeDestroy');\n const {canvas, ctx} = this;\n this._stop();\n this.config.clearCache();\n if (canvas) {\n this.unbindEvents();\n clearCanvas(canvas, ctx);\n this.platform.releaseContext(ctx);\n this.canvas = null;\n this.ctx = null;\n }\n this.notifyPlugins('destroy');\n delete instances[this.id];\n this.notifyPlugins('afterDestroy');\n }\n toBase64Image(...args) {\n return this.canvas.toDataURL(...args);\n }\n bindEvents() {\n this.bindUserEvents();\n if (this.options.responsive) {\n this.bindResponsiveEvents();\n } else {\n this.attached = true;\n }\n }\n bindUserEvents() {\n const listeners = this._listeners;\n const platform = this.platform;\n const _add = (type, listener) => {\n platform.addEventListener(this, type, listener);\n listeners[type] = listener;\n };\n const listener = (e, x, y) => {\n e.offsetX = x;\n e.offsetY = y;\n this._eventHandler(e);\n };\n each(this.options.events, (type) => _add(type, listener));\n }\n bindResponsiveEvents() {\n if (!this._responsiveListeners) {\n this._responsiveListeners = {};\n }\n const listeners = this._responsiveListeners;\n const platform = this.platform;\n const _add = (type, listener) => {\n platform.addEventListener(this, type, listener);\n listeners[type] = listener;\n };\n const _remove = (type, listener) => {\n if (listeners[type]) {\n platform.removeEventListener(this, type, listener);\n delete listeners[type];\n }\n };\n const listener = (width, height) => {\n if (this.canvas) {\n this.resize(width, height);\n }\n };\n let detached;\n const attached = () => {\n _remove('attach', attached);\n this.attached = true;\n this.resize();\n _add('resize', listener);\n _add('detach', detached);\n };\n detached = () => {\n this.attached = false;\n _remove('resize', listener);\n this._stop();\n this._resize(0, 0);\n _add('attach', attached);\n };\n if (platform.isAttached(this.canvas)) {\n attached();\n } else {\n detached();\n }\n }\n unbindEvents() {\n each(this._listeners, (listener, type) => {\n this.platform.removeEventListener(this, type, listener);\n });\n this._listeners = {};\n each(this._responsiveListeners, (listener, type) => {\n this.platform.removeEventListener(this, type, listener);\n });\n this._responsiveListeners = undefined;\n }\n updateHoverStyle(items, mode, enabled) {\n const prefix = enabled ? 'set' : 'remove';\n let meta, item, i, ilen;\n if (mode === 'dataset') {\n meta = this.getDatasetMeta(items[0].datasetIndex);\n meta.controller['_' + prefix + 'DatasetHoverStyle']();\n }\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n item = items[i];\n const controller = item && this.getDatasetMeta(item.datasetIndex).controller;\n if (controller) {\n controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index);\n }\n }\n }\n getActiveElements() {\n return this._active || [];\n }\n setActiveElements(activeElements) {\n const lastActive = this._active || [];\n const active = activeElements.map(({datasetIndex, index}) => {\n const meta = this.getDatasetMeta(datasetIndex);\n if (!meta) {\n throw new Error('No dataset found at index ' + datasetIndex);\n }\n return {\n datasetIndex,\n element: meta.data[index],\n index,\n };\n });\n const changed = !_elementsEqual(active, lastActive);\n if (changed) {\n this._active = active;\n this._lastEvent = null;\n this._updateHoverStyles(active, lastActive);\n }\n }\n notifyPlugins(hook, args, filter) {\n return this._plugins.notify(this, hook, args, filter);\n }\n _updateHoverStyles(active, lastActive, replay) {\n const hoverOptions = this.options.hover;\n const diff = (a, b) => a.filter(x => !b.some(y => x.datasetIndex === y.datasetIndex && x.index === y.index));\n const deactivated = diff(lastActive, active);\n const activated = replay ? active : diff(active, lastActive);\n if (deactivated.length) {\n this.updateHoverStyle(deactivated, hoverOptions.mode, false);\n }\n if (activated.length && hoverOptions.mode) {\n this.updateHoverStyle(activated, hoverOptions.mode, true);\n }\n }\n _eventHandler(e, replay) {\n const args = {\n event: e,\n replay,\n cancelable: true,\n inChartArea: this.isPointInArea(e)\n };\n const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type);\n if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) {\n return;\n }\n const changed = this._handleEvent(e, replay, args.inChartArea);\n args.cancelable = false;\n this.notifyPlugins('afterEvent', args, eventFilter);\n if (changed || args.changed) {\n this.render();\n }\n return this;\n }\n _handleEvent(e, replay, inChartArea) {\n const {_active: lastActive = [], options} = this;\n const useFinalPosition = replay;\n const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition);\n const isClick = _isClickEvent(e);\n const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick);\n if (inChartArea) {\n this._lastEvent = null;\n callback(options.onHover, [e, active, this], this);\n if (isClick) {\n callback(options.onClick, [e, active, this], this);\n }\n }\n const changed = !_elementsEqual(active, lastActive);\n if (changed || replay) {\n this._active = active;\n this._updateHoverStyles(active, lastActive, replay);\n }\n this._lastEvent = lastEvent;\n return changed;\n }\n _getActiveElements(e, lastActive, inChartArea, useFinalPosition) {\n if (e.type === 'mouseout') {\n return [];\n }\n if (!inChartArea) {\n return lastActive;\n }\n const hoverOptions = this.options.hover;\n return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);\n }\n}\nconst invalidatePlugins = () => each(Chart.instances, (chart) => chart._plugins.invalidate());\nconst enumerable = true;\nObject.defineProperties(Chart, {\n defaults: {\n enumerable,\n value: defaults\n },\n instances: {\n enumerable,\n value: instances\n },\n overrides: {\n enumerable,\n value: overrides\n },\n registry: {\n enumerable,\n value: registry\n },\n version: {\n enumerable,\n value: version\n },\n getChart: {\n enumerable,\n value: getChart\n },\n register: {\n enumerable,\n value: (...items) => {\n registry.add(...items);\n invalidatePlugins();\n }\n },\n unregister: {\n enumerable,\n value: (...items) => {\n registry.remove(...items);\n invalidatePlugins();\n }\n }\n});\n\nfunction clipArc(ctx, element, endAngle) {\n const {startAngle, pixelMargin, x, y, outerRadius, innerRadius} = element;\n let angleMargin = pixelMargin / outerRadius;\n ctx.beginPath();\n ctx.arc(x, y, outerRadius, startAngle - angleMargin, endAngle + angleMargin);\n if (innerRadius > pixelMargin) {\n angleMargin = pixelMargin / innerRadius;\n ctx.arc(x, y, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true);\n } else {\n ctx.arc(x, y, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI);\n }\n ctx.closePath();\n ctx.clip();\n}\nfunction toRadiusCorners(value) {\n return _readValueToProps(value, ['outerStart', 'outerEnd', 'innerStart', 'innerEnd']);\n}\nfunction parseBorderRadius$1(arc, innerRadius, outerRadius, angleDelta) {\n const o = toRadiusCorners(arc.options.borderRadius);\n const halfThickness = (outerRadius - innerRadius) / 2;\n const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2);\n const computeOuterLimit = (val) => {\n const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2;\n return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit));\n };\n return {\n outerStart: computeOuterLimit(o.outerStart),\n outerEnd: computeOuterLimit(o.outerEnd),\n innerStart: _limitValue(o.innerStart, 0, innerLimit),\n innerEnd: _limitValue(o.innerEnd, 0, innerLimit),\n };\n}\nfunction rThetaToXY(r, theta, x, y) {\n return {\n x: x + r * Math.cos(theta),\n y: y + r * Math.sin(theta),\n };\n}\nfunction pathArc(ctx, element, offset, spacing, end) {\n const {x, y, startAngle: start, pixelMargin, innerRadius: innerR} = element;\n const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0);\n const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0;\n let spacingOffset = 0;\n const alpha = end - start;\n if (spacing) {\n const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0;\n const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0;\n const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2;\n const adjustedAngle = avNogSpacingRadius !== 0 ? (alpha * avNogSpacingRadius) / (avNogSpacingRadius + spacing) : alpha;\n spacingOffset = (alpha - adjustedAngle) / 2;\n }\n const beta = Math.max(0.001, alpha * outerRadius - offset / PI) / outerRadius;\n const angleOffset = (alpha - beta) / 2;\n const startAngle = start + angleOffset + spacingOffset;\n const endAngle = end - angleOffset - spacingOffset;\n const {outerStart, outerEnd, innerStart, innerEnd} = parseBorderRadius$1(element, innerRadius, outerRadius, endAngle - startAngle);\n const outerStartAdjustedRadius = outerRadius - outerStart;\n const outerEndAdjustedRadius = outerRadius - outerEnd;\n const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius;\n const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius;\n const innerStartAdjustedRadius = innerRadius + innerStart;\n const innerEndAdjustedRadius = innerRadius + innerEnd;\n const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius;\n const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius;\n ctx.beginPath();\n ctx.arc(x, y, outerRadius, outerStartAdjustedAngle, outerEndAdjustedAngle);\n if (outerEnd > 0) {\n const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x, y);\n ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI);\n }\n const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x, y);\n ctx.lineTo(p4.x, p4.y);\n if (innerEnd > 0) {\n const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x, y);\n ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI);\n }\n ctx.arc(x, y, innerRadius, endAngle - (innerEnd / innerRadius), startAngle + (innerStart / innerRadius), true);\n if (innerStart > 0) {\n const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x, y);\n ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI);\n }\n const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x, y);\n ctx.lineTo(p8.x, p8.y);\n if (outerStart > 0) {\n const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x, y);\n ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle);\n }\n ctx.closePath();\n}\nfunction drawArc(ctx, element, offset, spacing) {\n const {fullCircles, startAngle, circumference} = element;\n let endAngle = element.endAngle;\n if (fullCircles) {\n pathArc(ctx, element, offset, spacing, startAngle + TAU);\n for (let i = 0; i < fullCircles; ++i) {\n ctx.fill();\n }\n if (!isNaN(circumference)) {\n endAngle = startAngle + circumference % TAU;\n if (circumference % TAU === 0) {\n endAngle += TAU;\n }\n }\n }\n pathArc(ctx, element, offset, spacing, endAngle);\n ctx.fill();\n return endAngle;\n}\nfunction drawFullCircleBorders(ctx, element, inner) {\n const {x, y, startAngle, pixelMargin, fullCircles} = element;\n const outerRadius = Math.max(element.outerRadius - pixelMargin, 0);\n const innerRadius = element.innerRadius + pixelMargin;\n let i;\n if (inner) {\n clipArc(ctx, element, startAngle + TAU);\n }\n ctx.beginPath();\n ctx.arc(x, y, innerRadius, startAngle + TAU, startAngle, true);\n for (i = 0; i < fullCircles; ++i) {\n ctx.stroke();\n }\n ctx.beginPath();\n ctx.arc(x, y, outerRadius, startAngle, startAngle + TAU);\n for (i = 0; i < fullCircles; ++i) {\n ctx.stroke();\n }\n}\nfunction drawBorder(ctx, element, offset, spacing, endAngle) {\n const {options} = element;\n const {borderWidth, borderJoinStyle} = options;\n const inner = options.borderAlign === 'inner';\n if (!borderWidth) {\n return;\n }\n if (inner) {\n ctx.lineWidth = borderWidth * 2;\n ctx.lineJoin = borderJoinStyle || 'round';\n } else {\n ctx.lineWidth = borderWidth;\n ctx.lineJoin = borderJoinStyle || 'bevel';\n }\n if (element.fullCircles) {\n drawFullCircleBorders(ctx, element, inner);\n }\n if (inner) {\n clipArc(ctx, element, endAngle);\n }\n pathArc(ctx, element, offset, spacing, endAngle);\n ctx.stroke();\n}\nclass ArcElement extends Element {\n constructor(cfg) {\n super();\n this.options = undefined;\n this.circumference = undefined;\n this.startAngle = undefined;\n this.endAngle = undefined;\n this.innerRadius = undefined;\n this.outerRadius = undefined;\n this.pixelMargin = 0;\n this.fullCircles = 0;\n if (cfg) {\n Object.assign(this, cfg);\n }\n }\n inRange(chartX, chartY, useFinalPosition) {\n const point = this.getProps(['x', 'y'], useFinalPosition);\n const {angle, distance} = getAngleFromPoint(point, {x: chartX, y: chartY});\n const {startAngle, endAngle, innerRadius, outerRadius, circumference} = this.getProps([\n 'startAngle',\n 'endAngle',\n 'innerRadius',\n 'outerRadius',\n 'circumference'\n ], useFinalPosition);\n const rAdjust = this.options.spacing / 2;\n const _circumference = valueOrDefault(circumference, endAngle - startAngle);\n const betweenAngles = _circumference >= TAU || _angleBetween(angle, startAngle, endAngle);\n const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust);\n return (betweenAngles && withinRadius);\n }\n getCenterPoint(useFinalPosition) {\n const {x, y, startAngle, endAngle, innerRadius, outerRadius} = this.getProps([\n 'x',\n 'y',\n 'startAngle',\n 'endAngle',\n 'innerRadius',\n 'outerRadius',\n 'circumference',\n ], useFinalPosition);\n const {offset, spacing} = this.options;\n const halfAngle = (startAngle + endAngle) / 2;\n const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2;\n return {\n x: x + Math.cos(halfAngle) * halfRadius,\n y: y + Math.sin(halfAngle) * halfRadius\n };\n }\n tooltipPosition(useFinalPosition) {\n return this.getCenterPoint(useFinalPosition);\n }\n draw(ctx) {\n const {options, circumference} = this;\n const offset = (options.offset || 0) / 2;\n const spacing = (options.spacing || 0) / 2;\n this.pixelMargin = (options.borderAlign === 'inner') ? 0.33 : 0;\n this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0;\n if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) {\n return;\n }\n ctx.save();\n let radiusOffset = 0;\n if (offset) {\n radiusOffset = offset / 2;\n const halfAngle = (this.startAngle + this.endAngle) / 2;\n ctx.translate(Math.cos(halfAngle) * radiusOffset, Math.sin(halfAngle) * radiusOffset);\n if (this.circumference >= PI) {\n radiusOffset = offset;\n }\n }\n ctx.fillStyle = options.backgroundColor;\n ctx.strokeStyle = options.borderColor;\n const endAngle = drawArc(ctx, this, radiusOffset, spacing);\n drawBorder(ctx, this, radiusOffset, spacing, endAngle);\n ctx.restore();\n }\n}\nArcElement.id = 'arc';\nArcElement.defaults = {\n borderAlign: 'center',\n borderColor: '#fff',\n borderJoinStyle: undefined,\n borderRadius: 0,\n borderWidth: 2,\n offset: 0,\n spacing: 0,\n angle: undefined,\n};\nArcElement.defaultRoutes = {\n backgroundColor: 'backgroundColor'\n};\n\nfunction setStyle(ctx, options, style = options) {\n ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle);\n ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash));\n ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset);\n ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle);\n ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth);\n ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor);\n}\nfunction lineTo(ctx, previous, target) {\n ctx.lineTo(target.x, target.y);\n}\nfunction getLineMethod(options) {\n if (options.stepped) {\n return _steppedLineTo;\n }\n if (options.tension || options.cubicInterpolationMode === 'monotone') {\n return _bezierCurveTo;\n }\n return lineTo;\n}\nfunction pathVars(points, segment, params = {}) {\n const count = points.length;\n const {start: paramsStart = 0, end: paramsEnd = count - 1} = params;\n const {start: segmentStart, end: segmentEnd} = segment;\n const start = Math.max(paramsStart, segmentStart);\n const end = Math.min(paramsEnd, segmentEnd);\n const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd;\n return {\n count,\n start,\n loop: segment.loop,\n ilen: end < start && !outside ? count + end - start : end - start\n };\n}\nfunction pathSegment(ctx, line, segment, params) {\n const {points, options} = line;\n const {count, start, loop, ilen} = pathVars(points, segment, params);\n const lineMethod = getLineMethod(options);\n let {move = true, reverse} = params || {};\n let i, point, prev;\n for (i = 0; i <= ilen; ++i) {\n point = points[(start + (reverse ? ilen - i : i)) % count];\n if (point.skip) {\n continue;\n } else if (move) {\n ctx.moveTo(point.x, point.y);\n move = false;\n } else {\n lineMethod(ctx, prev, point, reverse, options.stepped);\n }\n prev = point;\n }\n if (loop) {\n point = points[(start + (reverse ? ilen : 0)) % count];\n lineMethod(ctx, prev, point, reverse, options.stepped);\n }\n return !!loop;\n}\nfunction fastPathSegment(ctx, line, segment, params) {\n const points = line.points;\n const {count, start, ilen} = pathVars(points, segment, params);\n const {move = true, reverse} = params || {};\n let avgX = 0;\n let countX = 0;\n let i, point, prevX, minY, maxY, lastY;\n const pointIndex = (index) => (start + (reverse ? ilen - index : index)) % count;\n const drawX = () => {\n if (minY !== maxY) {\n ctx.lineTo(avgX, maxY);\n ctx.lineTo(avgX, minY);\n ctx.lineTo(avgX, lastY);\n }\n };\n if (move) {\n point = points[pointIndex(0)];\n ctx.moveTo(point.x, point.y);\n }\n for (i = 0; i <= ilen; ++i) {\n point = points[pointIndex(i)];\n if (point.skip) {\n continue;\n }\n const x = point.x;\n const y = point.y;\n const truncX = x | 0;\n if (truncX === prevX) {\n if (y < minY) {\n minY = y;\n } else if (y > maxY) {\n maxY = y;\n }\n avgX = (countX * avgX + x) / ++countX;\n } else {\n drawX();\n ctx.lineTo(x, y);\n prevX = truncX;\n countX = 0;\n minY = maxY = y;\n }\n lastY = y;\n }\n drawX();\n}\nfunction _getSegmentMethod(line) {\n const opts = line.options;\n const borderDash = opts.borderDash && opts.borderDash.length;\n const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== 'monotone' && !opts.stepped && !borderDash;\n return useFastPath ? fastPathSegment : pathSegment;\n}\nfunction _getInterpolationMethod(options) {\n if (options.stepped) {\n return _steppedInterpolation;\n }\n if (options.tension || options.cubicInterpolationMode === 'monotone') {\n return _bezierInterpolation;\n }\n return _pointInLine;\n}\nfunction strokePathWithCache(ctx, line, start, count) {\n let path = line._path;\n if (!path) {\n path = line._path = new Path2D();\n if (line.path(path, start, count)) {\n path.closePath();\n }\n }\n setStyle(ctx, line.options);\n ctx.stroke(path);\n}\nfunction strokePathDirect(ctx, line, start, count) {\n const {segments, options} = line;\n const segmentMethod = _getSegmentMethod(line);\n for (const segment of segments) {\n setStyle(ctx, options, segment.style);\n ctx.beginPath();\n if (segmentMethod(ctx, line, segment, {start, end: start + count - 1})) {\n ctx.closePath();\n }\n ctx.stroke();\n }\n}\nconst usePath2D = typeof Path2D === 'function';\nfunction draw(ctx, line, start, count) {\n if (usePath2D && !line.options.segment) {\n strokePathWithCache(ctx, line, start, count);\n } else {\n strokePathDirect(ctx, line, start, count);\n }\n}\nclass LineElement extends Element {\n constructor(cfg) {\n super();\n this.animated = true;\n this.options = undefined;\n this._chart = undefined;\n this._loop = undefined;\n this._fullLoop = undefined;\n this._path = undefined;\n this._points = undefined;\n this._segments = undefined;\n this._decimated = false;\n this._pointsUpdated = false;\n this._datasetIndex = undefined;\n if (cfg) {\n Object.assign(this, cfg);\n }\n }\n updateControlPoints(chartArea, indexAxis) {\n const options = this.options;\n if ((options.tension || options.cubicInterpolationMode === 'monotone') && !options.stepped && !this._pointsUpdated) {\n const loop = options.spanGaps ? this._loop : this._fullLoop;\n _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis);\n this._pointsUpdated = true;\n }\n }\n set points(points) {\n this._points = points;\n delete this._segments;\n delete this._path;\n this._pointsUpdated = false;\n }\n get points() {\n return this._points;\n }\n get segments() {\n return this._segments || (this._segments = _computeSegments(this, this.options.segment));\n }\n first() {\n const segments = this.segments;\n const points = this.points;\n return segments.length && points[segments[0].start];\n }\n last() {\n const segments = this.segments;\n const points = this.points;\n const count = segments.length;\n return count && points[segments[count - 1].end];\n }\n interpolate(point, property) {\n const options = this.options;\n const value = point[property];\n const points = this.points;\n const segments = _boundSegments(this, {property, start: value, end: value});\n if (!segments.length) {\n return;\n }\n const result = [];\n const _interpolate = _getInterpolationMethod(options);\n let i, ilen;\n for (i = 0, ilen = segments.length; i < ilen; ++i) {\n const {start, end} = segments[i];\n const p1 = points[start];\n const p2 = points[end];\n if (p1 === p2) {\n result.push(p1);\n continue;\n }\n const t = Math.abs((value - p1[property]) / (p2[property] - p1[property]));\n const interpolated = _interpolate(p1, p2, t, options.stepped);\n interpolated[property] = point[property];\n result.push(interpolated);\n }\n return result.length === 1 ? result[0] : result;\n }\n pathSegment(ctx, segment, params) {\n const segmentMethod = _getSegmentMethod(this);\n return segmentMethod(ctx, this, segment, params);\n }\n path(ctx, start, count) {\n const segments = this.segments;\n const segmentMethod = _getSegmentMethod(this);\n let loop = this._loop;\n start = start || 0;\n count = count || (this.points.length - start);\n for (const segment of segments) {\n loop &= segmentMethod(ctx, this, segment, {start, end: start + count - 1});\n }\n return !!loop;\n }\n draw(ctx, chartArea, start, count) {\n const options = this.options || {};\n const points = this.points || [];\n if (points.length && options.borderWidth) {\n ctx.save();\n draw(ctx, this, start, count);\n ctx.restore();\n }\n if (this.animated) {\n this._pointsUpdated = false;\n this._path = undefined;\n }\n }\n}\nLineElement.id = 'line';\nLineElement.defaults = {\n borderCapStyle: 'butt',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderWidth: 3,\n capBezierPoints: true,\n cubicInterpolationMode: 'default',\n fill: false,\n spanGaps: false,\n stepped: false,\n tension: 0,\n};\nLineElement.defaultRoutes = {\n backgroundColor: 'backgroundColor',\n borderColor: 'borderColor'\n};\nLineElement.descriptors = {\n _scriptable: true,\n _indexable: (name) => name !== 'borderDash' && name !== 'fill',\n};\n\nfunction inRange$1(el, pos, axis, useFinalPosition) {\n const options = el.options;\n const {[axis]: value} = el.getProps([axis], useFinalPosition);\n return (Math.abs(pos - value) < options.radius + options.hitRadius);\n}\nclass PointElement extends Element {\n constructor(cfg) {\n super();\n this.options = undefined;\n this.parsed = undefined;\n this.skip = undefined;\n this.stop = undefined;\n if (cfg) {\n Object.assign(this, cfg);\n }\n }\n inRange(mouseX, mouseY, useFinalPosition) {\n const options = this.options;\n const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n return ((Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2)) < Math.pow(options.hitRadius + options.radius, 2));\n }\n inXRange(mouseX, useFinalPosition) {\n return inRange$1(this, mouseX, 'x', useFinalPosition);\n }\n inYRange(mouseY, useFinalPosition) {\n return inRange$1(this, mouseY, 'y', useFinalPosition);\n }\n getCenterPoint(useFinalPosition) {\n const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n return {x, y};\n }\n size(options) {\n options = options || this.options || {};\n let radius = options.radius || 0;\n radius = Math.max(radius, radius && options.hoverRadius || 0);\n const borderWidth = radius && options.borderWidth || 0;\n return (radius + borderWidth) * 2;\n }\n draw(ctx, area) {\n const options = this.options;\n if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) {\n return;\n }\n ctx.strokeStyle = options.borderColor;\n ctx.lineWidth = options.borderWidth;\n ctx.fillStyle = options.backgroundColor;\n drawPoint(ctx, options, this.x, this.y);\n }\n getRange() {\n const options = this.options || {};\n return options.radius + options.hitRadius;\n }\n}\nPointElement.id = 'point';\nPointElement.defaults = {\n borderWidth: 1,\n hitRadius: 1,\n hoverBorderWidth: 1,\n hoverRadius: 4,\n pointStyle: 'circle',\n radius: 3,\n rotation: 0\n};\nPointElement.defaultRoutes = {\n backgroundColor: 'backgroundColor',\n borderColor: 'borderColor'\n};\n\nfunction getBarBounds(bar, useFinalPosition) {\n const {x, y, base, width, height} = bar.getProps(['x', 'y', 'base', 'width', 'height'], useFinalPosition);\n let left, right, top, bottom, half;\n if (bar.horizontal) {\n half = height / 2;\n left = Math.min(x, base);\n right = Math.max(x, base);\n top = y - half;\n bottom = y + half;\n } else {\n half = width / 2;\n left = x - half;\n right = x + half;\n top = Math.min(y, base);\n bottom = Math.max(y, base);\n }\n return {left, top, right, bottom};\n}\nfunction skipOrLimit(skip, value, min, max) {\n return skip ? 0 : _limitValue(value, min, max);\n}\nfunction parseBorderWidth(bar, maxW, maxH) {\n const value = bar.options.borderWidth;\n const skip = bar.borderSkipped;\n const o = toTRBL(value);\n return {\n t: skipOrLimit(skip.top, o.top, 0, maxH),\n r: skipOrLimit(skip.right, o.right, 0, maxW),\n b: skipOrLimit(skip.bottom, o.bottom, 0, maxH),\n l: skipOrLimit(skip.left, o.left, 0, maxW)\n };\n}\nfunction parseBorderRadius(bar, maxW, maxH) {\n const {enableBorderRadius} = bar.getProps(['enableBorderRadius']);\n const value = bar.options.borderRadius;\n const o = toTRBLCorners(value);\n const maxR = Math.min(maxW, maxH);\n const skip = bar.borderSkipped;\n const enableBorder = enableBorderRadius || isObject(value);\n return {\n topLeft: skipOrLimit(!enableBorder || skip.top || skip.left, o.topLeft, 0, maxR),\n topRight: skipOrLimit(!enableBorder || skip.top || skip.right, o.topRight, 0, maxR),\n bottomLeft: skipOrLimit(!enableBorder || skip.bottom || skip.left, o.bottomLeft, 0, maxR),\n bottomRight: skipOrLimit(!enableBorder || skip.bottom || skip.right, o.bottomRight, 0, maxR)\n };\n}\nfunction boundingRects(bar) {\n const bounds = getBarBounds(bar);\n const width = bounds.right - bounds.left;\n const height = bounds.bottom - bounds.top;\n const border = parseBorderWidth(bar, width / 2, height / 2);\n const radius = parseBorderRadius(bar, width / 2, height / 2);\n return {\n outer: {\n x: bounds.left,\n y: bounds.top,\n w: width,\n h: height,\n radius\n },\n inner: {\n x: bounds.left + border.l,\n y: bounds.top + border.t,\n w: width - border.l - border.r,\n h: height - border.t - border.b,\n radius: {\n topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)),\n topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)),\n bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)),\n bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r)),\n }\n }\n };\n}\nfunction inRange(bar, x, y, useFinalPosition) {\n const skipX = x === null;\n const skipY = y === null;\n const skipBoth = skipX && skipY;\n const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);\n return bounds\n\t\t&& (skipX || _isBetween(x, bounds.left, bounds.right))\n\t\t&& (skipY || _isBetween(y, bounds.top, bounds.bottom));\n}\nfunction hasRadius(radius) {\n return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;\n}\nfunction addNormalRectPath(ctx, rect) {\n ctx.rect(rect.x, rect.y, rect.w, rect.h);\n}\nfunction inflateRect(rect, amount, refRect = {}) {\n const x = rect.x !== refRect.x ? -amount : 0;\n const y = rect.y !== refRect.y ? -amount : 0;\n const w = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x;\n const h = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y;\n return {\n x: rect.x + x,\n y: rect.y + y,\n w: rect.w + w,\n h: rect.h + h,\n radius: rect.radius\n };\n}\nclass BarElement extends Element {\n constructor(cfg) {\n super();\n this.options = undefined;\n this.horizontal = undefined;\n this.base = undefined;\n this.width = undefined;\n this.height = undefined;\n this.inflateAmount = undefined;\n if (cfg) {\n Object.assign(this, cfg);\n }\n }\n draw(ctx) {\n const {inflateAmount, options: {borderColor, backgroundColor}} = this;\n const {inner, outer} = boundingRects(this);\n const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath;\n ctx.save();\n if (outer.w !== inner.w || outer.h !== inner.h) {\n ctx.beginPath();\n addRectPath(ctx, inflateRect(outer, inflateAmount, inner));\n ctx.clip();\n addRectPath(ctx, inflateRect(inner, -inflateAmount, outer));\n ctx.fillStyle = borderColor;\n ctx.fill('evenodd');\n }\n ctx.beginPath();\n addRectPath(ctx, inflateRect(inner, inflateAmount));\n ctx.fillStyle = backgroundColor;\n ctx.fill();\n ctx.restore();\n }\n inRange(mouseX, mouseY, useFinalPosition) {\n return inRange(this, mouseX, mouseY, useFinalPosition);\n }\n inXRange(mouseX, useFinalPosition) {\n return inRange(this, mouseX, null, useFinalPosition);\n }\n inYRange(mouseY, useFinalPosition) {\n return inRange(this, null, mouseY, useFinalPosition);\n }\n getCenterPoint(useFinalPosition) {\n const {x, y, base, horizontal} = this.getProps(['x', 'y', 'base', 'horizontal'], useFinalPosition);\n return {\n x: horizontal ? (x + base) / 2 : x,\n y: horizontal ? y : (y + base) / 2\n };\n }\n getRange(axis) {\n return axis === 'x' ? this.width / 2 : this.height / 2;\n }\n}\nBarElement.id = 'bar';\nBarElement.defaults = {\n borderSkipped: 'start',\n borderWidth: 0,\n borderRadius: 0,\n inflateAmount: 'auto',\n pointStyle: undefined\n};\nBarElement.defaultRoutes = {\n backgroundColor: 'backgroundColor',\n borderColor: 'borderColor'\n};\n\nvar elements = /*#__PURE__*/Object.freeze({\n__proto__: null,\nArcElement: ArcElement,\nLineElement: LineElement,\nPointElement: PointElement,\nBarElement: BarElement\n});\n\nfunction lttbDecimation(data, start, count, availableWidth, options) {\n const samples = options.samples || availableWidth;\n if (samples >= count) {\n return data.slice(start, start + count);\n }\n const decimated = [];\n const bucketWidth = (count - 2) / (samples - 2);\n let sampledIndex = 0;\n const endIndex = start + count - 1;\n let a = start;\n let i, maxAreaPoint, maxArea, area, nextA;\n decimated[sampledIndex++] = data[a];\n for (i = 0; i < samples - 2; i++) {\n let avgX = 0;\n let avgY = 0;\n let j;\n const avgRangeStart = Math.floor((i + 1) * bucketWidth) + 1 + start;\n const avgRangeEnd = Math.min(Math.floor((i + 2) * bucketWidth) + 1, count) + start;\n const avgRangeLength = avgRangeEnd - avgRangeStart;\n for (j = avgRangeStart; j < avgRangeEnd; j++) {\n avgX += data[j].x;\n avgY += data[j].y;\n }\n avgX /= avgRangeLength;\n avgY /= avgRangeLength;\n const rangeOffs = Math.floor(i * bucketWidth) + 1 + start;\n const rangeTo = Math.min(Math.floor((i + 1) * bucketWidth) + 1, count) + start;\n const {x: pointAx, y: pointAy} = data[a];\n maxArea = area = -1;\n for (j = rangeOffs; j < rangeTo; j++) {\n area = 0.5 * Math.abs(\n (pointAx - avgX) * (data[j].y - pointAy) -\n (pointAx - data[j].x) * (avgY - pointAy)\n );\n if (area > maxArea) {\n maxArea = area;\n maxAreaPoint = data[j];\n nextA = j;\n }\n }\n decimated[sampledIndex++] = maxAreaPoint;\n a = nextA;\n }\n decimated[sampledIndex++] = data[endIndex];\n return decimated;\n}\nfunction minMaxDecimation(data, start, count, availableWidth) {\n let avgX = 0;\n let countX = 0;\n let i, point, x, y, prevX, minIndex, maxIndex, startIndex, minY, maxY;\n const decimated = [];\n const endIndex = start + count - 1;\n const xMin = data[start].x;\n const xMax = data[endIndex].x;\n const dx = xMax - xMin;\n for (i = start; i < start + count; ++i) {\n point = data[i];\n x = (point.x - xMin) / dx * availableWidth;\n y = point.y;\n const truncX = x | 0;\n if (truncX === prevX) {\n if (y < minY) {\n minY = y;\n minIndex = i;\n } else if (y > maxY) {\n maxY = y;\n maxIndex = i;\n }\n avgX = (countX * avgX + point.x) / ++countX;\n } else {\n const lastIndex = i - 1;\n if (!isNullOrUndef(minIndex) && !isNullOrUndef(maxIndex)) {\n const intermediateIndex1 = Math.min(minIndex, maxIndex);\n const intermediateIndex2 = Math.max(minIndex, maxIndex);\n if (intermediateIndex1 !== startIndex && intermediateIndex1 !== lastIndex) {\n decimated.push({\n ...data[intermediateIndex1],\n x: avgX,\n });\n }\n if (intermediateIndex2 !== startIndex && intermediateIndex2 !== lastIndex) {\n decimated.push({\n ...data[intermediateIndex2],\n x: avgX\n });\n }\n }\n if (i > 0 && lastIndex !== startIndex) {\n decimated.push(data[lastIndex]);\n }\n decimated.push(point);\n prevX = truncX;\n countX = 0;\n minY = maxY = y;\n minIndex = maxIndex = startIndex = i;\n }\n }\n return decimated;\n}\nfunction cleanDecimatedDataset(dataset) {\n if (dataset._decimated) {\n const data = dataset._data;\n delete dataset._decimated;\n delete dataset._data;\n Object.defineProperty(dataset, 'data', {value: data});\n }\n}\nfunction cleanDecimatedData(chart) {\n chart.data.datasets.forEach((dataset) => {\n cleanDecimatedDataset(dataset);\n });\n}\nfunction getStartAndCountOfVisiblePointsSimplified(meta, points) {\n const pointCount = points.length;\n let start = 0;\n let count;\n const {iScale} = meta;\n const {min, max, minDefined, maxDefined} = iScale.getUserBounds();\n if (minDefined) {\n start = _limitValue(_lookupByKey(points, iScale.axis, min).lo, 0, pointCount - 1);\n }\n if (maxDefined) {\n count = _limitValue(_lookupByKey(points, iScale.axis, max).hi + 1, start, pointCount) - start;\n } else {\n count = pointCount - start;\n }\n return {start, count};\n}\nvar plugin_decimation = {\n id: 'decimation',\n defaults: {\n algorithm: 'min-max',\n enabled: false,\n },\n beforeElementsUpdate: (chart, args, options) => {\n if (!options.enabled) {\n cleanDecimatedData(chart);\n return;\n }\n const availableWidth = chart.width;\n chart.data.datasets.forEach((dataset, datasetIndex) => {\n const {_data, indexAxis} = dataset;\n const meta = chart.getDatasetMeta(datasetIndex);\n const data = _data || dataset.data;\n if (resolve([indexAxis, chart.options.indexAxis]) === 'y') {\n return;\n }\n if (!meta.controller.supportsDecimation) {\n return;\n }\n const xAxis = chart.scales[meta.xAxisID];\n if (xAxis.type !== 'linear' && xAxis.type !== 'time') {\n return;\n }\n if (chart.options.parsing) {\n return;\n }\n let {start, count} = getStartAndCountOfVisiblePointsSimplified(meta, data);\n const threshold = options.threshold || 4 * availableWidth;\n if (count <= threshold) {\n cleanDecimatedDataset(dataset);\n return;\n }\n if (isNullOrUndef(_data)) {\n dataset._data = data;\n delete dataset.data;\n Object.defineProperty(dataset, 'data', {\n configurable: true,\n enumerable: true,\n get: function() {\n return this._decimated;\n },\n set: function(d) {\n this._data = d;\n }\n });\n }\n let decimated;\n switch (options.algorithm) {\n case 'lttb':\n decimated = lttbDecimation(data, start, count, availableWidth, options);\n break;\n case 'min-max':\n decimated = minMaxDecimation(data, start, count, availableWidth);\n break;\n default:\n throw new Error(`Unsupported decimation algorithm '${options.algorithm}'`);\n }\n dataset._decimated = decimated;\n });\n },\n destroy(chart) {\n cleanDecimatedData(chart);\n }\n};\n\nfunction _segments(line, target, property) {\n const segments = line.segments;\n const points = line.points;\n const tpoints = target.points;\n const parts = [];\n for (const segment of segments) {\n let {start, end} = segment;\n end = _findSegmentEnd(start, end, points);\n const bounds = _getBounds(property, points[start], points[end], segment.loop);\n if (!target.segments) {\n parts.push({\n source: segment,\n target: bounds,\n start: points[start],\n end: points[end]\n });\n continue;\n }\n const targetSegments = _boundSegments(target, bounds);\n for (const tgt of targetSegments) {\n const subBounds = _getBounds(property, tpoints[tgt.start], tpoints[tgt.end], tgt.loop);\n const fillSources = _boundSegment(segment, points, subBounds);\n for (const fillSource of fillSources) {\n parts.push({\n source: fillSource,\n target: tgt,\n start: {\n [property]: _getEdge(bounds, subBounds, 'start', Math.max)\n },\n end: {\n [property]: _getEdge(bounds, subBounds, 'end', Math.min)\n }\n });\n }\n }\n }\n return parts;\n}\nfunction _getBounds(property, first, last, loop) {\n if (loop) {\n return;\n }\n let start = first[property];\n let end = last[property];\n if (property === 'angle') {\n start = _normalizeAngle(start);\n end = _normalizeAngle(end);\n }\n return {property, start, end};\n}\nfunction _pointsFromSegments(boundary, line) {\n const {x = null, y = null} = boundary || {};\n const linePoints = line.points;\n const points = [];\n line.segments.forEach(({start, end}) => {\n end = _findSegmentEnd(start, end, linePoints);\n const first = linePoints[start];\n const last = linePoints[end];\n if (y !== null) {\n points.push({x: first.x, y});\n points.push({x: last.x, y});\n } else if (x !== null) {\n points.push({x, y: first.y});\n points.push({x, y: last.y});\n }\n });\n return points;\n}\nfunction _findSegmentEnd(start, end, points) {\n for (;end > start; end--) {\n const point = points[end];\n if (!isNaN(point.x) && !isNaN(point.y)) {\n break;\n }\n }\n return end;\n}\nfunction _getEdge(a, b, prop, fn) {\n if (a && b) {\n return fn(a[prop], b[prop]);\n }\n return a ? a[prop] : b ? b[prop] : 0;\n}\n\nfunction _createBoundaryLine(boundary, line) {\n let points = [];\n let _loop = false;\n if (isArray(boundary)) {\n _loop = true;\n points = boundary;\n } else {\n points = _pointsFromSegments(boundary, line);\n }\n return points.length ? new LineElement({\n points,\n options: {tension: 0},\n _loop,\n _fullLoop: _loop\n }) : null;\n}\n\nfunction _resolveTarget(sources, index, propagate) {\n const source = sources[index];\n let fill = source.fill;\n const visited = [index];\n let target;\n if (!propagate) {\n return fill;\n }\n while (fill !== false && visited.indexOf(fill) === -1) {\n if (!isNumberFinite(fill)) {\n return fill;\n }\n target = sources[fill];\n if (!target) {\n return false;\n }\n if (target.visible) {\n return fill;\n }\n visited.push(fill);\n fill = target.fill;\n }\n return false;\n}\nfunction _decodeFill(line, index, count) {\n const fill = parseFillOption(line);\n if (isObject(fill)) {\n return isNaN(fill.value) ? false : fill;\n }\n let target = parseFloat(fill);\n if (isNumberFinite(target) && Math.floor(target) === target) {\n return decodeTargetIndex(fill[0], index, target, count);\n }\n return ['origin', 'start', 'end', 'stack', 'shape'].indexOf(fill) >= 0 && fill;\n}\nfunction decodeTargetIndex(firstCh, index, target, count) {\n if (firstCh === '-' || firstCh === '+') {\n target = index + target;\n }\n if (target === index || target < 0 || target >= count) {\n return false;\n }\n return target;\n}\nfunction _getTargetPixel(fill, scale) {\n let pixel = null;\n if (fill === 'start') {\n pixel = scale.bottom;\n } else if (fill === 'end') {\n pixel = scale.top;\n } else if (isObject(fill)) {\n pixel = scale.getPixelForValue(fill.value);\n } else if (scale.getBasePixel) {\n pixel = scale.getBasePixel();\n }\n return pixel;\n}\nfunction _getTargetValue(fill, scale, startValue) {\n let value;\n if (fill === 'start') {\n value = startValue;\n } else if (fill === 'end') {\n value = scale.options.reverse ? scale.min : scale.max;\n } else if (isObject(fill)) {\n value = fill.value;\n } else {\n value = scale.getBaseValue();\n }\n return value;\n}\nfunction parseFillOption(line) {\n const options = line.options;\n const fillOption = options.fill;\n let fill = valueOrDefault(fillOption && fillOption.target, fillOption);\n if (fill === undefined) {\n fill = !!options.backgroundColor;\n }\n if (fill === false || fill === null) {\n return false;\n }\n if (fill === true) {\n return 'origin';\n }\n return fill;\n}\n\nfunction _buildStackLine(source) {\n const {scale, index, line} = source;\n const points = [];\n const segments = line.segments;\n const sourcePoints = line.points;\n const linesBelow = getLinesBelow(scale, index);\n linesBelow.push(_createBoundaryLine({x: null, y: scale.bottom}, line));\n for (let i = 0; i < segments.length; i++) {\n const segment = segments[i];\n for (let j = segment.start; j <= segment.end; j++) {\n addPointsBelow(points, sourcePoints[j], linesBelow);\n }\n }\n return new LineElement({points, options: {}});\n}\nfunction getLinesBelow(scale, index) {\n const below = [];\n const metas = scale.getMatchingVisibleMetas('line');\n for (let i = 0; i < metas.length; i++) {\n const meta = metas[i];\n if (meta.index === index) {\n break;\n }\n if (!meta.hidden) {\n below.unshift(meta.dataset);\n }\n }\n return below;\n}\nfunction addPointsBelow(points, sourcePoint, linesBelow) {\n const postponed = [];\n for (let j = 0; j < linesBelow.length; j++) {\n const line = linesBelow[j];\n const {first, last, point} = findPoint(line, sourcePoint, 'x');\n if (!point || (first && last)) {\n continue;\n }\n if (first) {\n postponed.unshift(point);\n } else {\n points.push(point);\n if (!last) {\n break;\n }\n }\n }\n points.push(...postponed);\n}\nfunction findPoint(line, sourcePoint, property) {\n const point = line.interpolate(sourcePoint, property);\n if (!point) {\n return {};\n }\n const pointValue = point[property];\n const segments = line.segments;\n const linePoints = line.points;\n let first = false;\n let last = false;\n for (let i = 0; i < segments.length; i++) {\n const segment = segments[i];\n const firstValue = linePoints[segment.start][property];\n const lastValue = linePoints[segment.end][property];\n if (_isBetween(pointValue, firstValue, lastValue)) {\n first = pointValue === firstValue;\n last = pointValue === lastValue;\n break;\n }\n }\n return {first, last, point};\n}\n\nclass simpleArc {\n constructor(opts) {\n this.x = opts.x;\n this.y = opts.y;\n this.radius = opts.radius;\n }\n pathSegment(ctx, bounds, opts) {\n const {x, y, radius} = this;\n bounds = bounds || {start: 0, end: TAU};\n ctx.arc(x, y, radius, bounds.end, bounds.start, true);\n return !opts.bounds;\n }\n interpolate(point) {\n const {x, y, radius} = this;\n const angle = point.angle;\n return {\n x: x + Math.cos(angle) * radius,\n y: y + Math.sin(angle) * radius,\n angle\n };\n }\n}\n\nfunction _getTarget(source) {\n const {chart, fill, line} = source;\n if (isNumberFinite(fill)) {\n return getLineByIndex(chart, fill);\n }\n if (fill === 'stack') {\n return _buildStackLine(source);\n }\n if (fill === 'shape') {\n return true;\n }\n const boundary = computeBoundary(source);\n if (boundary instanceof simpleArc) {\n return boundary;\n }\n return _createBoundaryLine(boundary, line);\n}\nfunction getLineByIndex(chart, index) {\n const meta = chart.getDatasetMeta(index);\n const visible = meta && chart.isDatasetVisible(index);\n return visible ? meta.dataset : null;\n}\nfunction computeBoundary(source) {\n const scale = source.scale || {};\n if (scale.getPointPositionForValue) {\n return computeCircularBoundary(source);\n }\n return computeLinearBoundary(source);\n}\nfunction computeLinearBoundary(source) {\n const {scale = {}, fill} = source;\n const pixel = _getTargetPixel(fill, scale);\n if (isNumberFinite(pixel)) {\n const horizontal = scale.isHorizontal();\n return {\n x: horizontal ? pixel : null,\n y: horizontal ? null : pixel\n };\n }\n return null;\n}\nfunction computeCircularBoundary(source) {\n const {scale, fill} = source;\n const options = scale.options;\n const length = scale.getLabels().length;\n const start = options.reverse ? scale.max : scale.min;\n const value = _getTargetValue(fill, scale, start);\n const target = [];\n if (options.grid.circular) {\n const center = scale.getPointPositionForValue(0, start);\n return new simpleArc({\n x: center.x,\n y: center.y,\n radius: scale.getDistanceFromCenterForValue(value)\n });\n }\n for (let i = 0; i < length; ++i) {\n target.push(scale.getPointPositionForValue(i, value));\n }\n return target;\n}\n\nfunction _drawfill(ctx, source, area) {\n const target = _getTarget(source);\n const {line, scale, axis} = source;\n const lineOpts = line.options;\n const fillOption = lineOpts.fill;\n const color = lineOpts.backgroundColor;\n const {above = color, below = color} = fillOption || {};\n if (target && line.points.length) {\n clipArea(ctx, area);\n doFill(ctx, {line, target, above, below, area, scale, axis});\n unclipArea(ctx);\n }\n}\nfunction doFill(ctx, cfg) {\n const {line, target, above, below, area, scale} = cfg;\n const property = line._loop ? 'angle' : cfg.axis;\n ctx.save();\n if (property === 'x' && below !== above) {\n clipVertical(ctx, target, area.top);\n fill(ctx, {line, target, color: above, scale, property});\n ctx.restore();\n ctx.save();\n clipVertical(ctx, target, area.bottom);\n }\n fill(ctx, {line, target, color: below, scale, property});\n ctx.restore();\n}\nfunction clipVertical(ctx, target, clipY) {\n const {segments, points} = target;\n let first = true;\n let lineLoop = false;\n ctx.beginPath();\n for (const segment of segments) {\n const {start, end} = segment;\n const firstPoint = points[start];\n const lastPoint = points[_findSegmentEnd(start, end, points)];\n if (first) {\n ctx.moveTo(firstPoint.x, firstPoint.y);\n first = false;\n } else {\n ctx.lineTo(firstPoint.x, clipY);\n ctx.lineTo(firstPoint.x, firstPoint.y);\n }\n lineLoop = !!target.pathSegment(ctx, segment, {move: lineLoop});\n if (lineLoop) {\n ctx.closePath();\n } else {\n ctx.lineTo(lastPoint.x, clipY);\n }\n }\n ctx.lineTo(target.first().x, clipY);\n ctx.closePath();\n ctx.clip();\n}\nfunction fill(ctx, cfg) {\n const {line, target, property, color, scale} = cfg;\n const segments = _segments(line, target, property);\n for (const {source: src, target: tgt, start, end} of segments) {\n const {style: {backgroundColor = color} = {}} = src;\n const notShape = target !== true;\n ctx.save();\n ctx.fillStyle = backgroundColor;\n clipBounds(ctx, scale, notShape && _getBounds(property, start, end));\n ctx.beginPath();\n const lineLoop = !!line.pathSegment(ctx, src);\n let loop;\n if (notShape) {\n if (lineLoop) {\n ctx.closePath();\n } else {\n interpolatedLineTo(ctx, target, end, property);\n }\n const targetLoop = !!target.pathSegment(ctx, tgt, {move: lineLoop, reverse: true});\n loop = lineLoop && targetLoop;\n if (!loop) {\n interpolatedLineTo(ctx, target, start, property);\n }\n }\n ctx.closePath();\n ctx.fill(loop ? 'evenodd' : 'nonzero');\n ctx.restore();\n }\n}\nfunction clipBounds(ctx, scale, bounds) {\n const {top, bottom} = scale.chart.chartArea;\n const {property, start, end} = bounds || {};\n if (property === 'x') {\n ctx.beginPath();\n ctx.rect(start, top, end - start, bottom - top);\n ctx.clip();\n }\n}\nfunction interpolatedLineTo(ctx, target, point, property) {\n const interpolatedPoint = target.interpolate(point, property);\n if (interpolatedPoint) {\n ctx.lineTo(interpolatedPoint.x, interpolatedPoint.y);\n }\n}\n\nvar index = {\n id: 'filler',\n afterDatasetsUpdate(chart, _args, options) {\n const count = (chart.data.datasets || []).length;\n const sources = [];\n let meta, i, line, source;\n for (i = 0; i < count; ++i) {\n meta = chart.getDatasetMeta(i);\n line = meta.dataset;\n source = null;\n if (line && line.options && line instanceof LineElement) {\n source = {\n visible: chart.isDatasetVisible(i),\n index: i,\n fill: _decodeFill(line, i, count),\n chart,\n axis: meta.controller.options.indexAxis,\n scale: meta.vScale,\n line,\n };\n }\n meta.$filler = source;\n sources.push(source);\n }\n for (i = 0; i < count; ++i) {\n source = sources[i];\n if (!source || source.fill === false) {\n continue;\n }\n source.fill = _resolveTarget(sources, i, options.propagate);\n }\n },\n beforeDraw(chart, _args, options) {\n const draw = options.drawTime === 'beforeDraw';\n const metasets = chart.getSortedVisibleDatasetMetas();\n const area = chart.chartArea;\n for (let i = metasets.length - 1; i >= 0; --i) {\n const source = metasets[i].$filler;\n if (!source) {\n continue;\n }\n source.line.updateControlPoints(area, source.axis);\n if (draw) {\n _drawfill(chart.ctx, source, area);\n }\n }\n },\n beforeDatasetsDraw(chart, _args, options) {\n if (options.drawTime !== 'beforeDatasetsDraw') {\n return;\n }\n const metasets = chart.getSortedVisibleDatasetMetas();\n for (let i = metasets.length - 1; i >= 0; --i) {\n const source = metasets[i].$filler;\n if (source) {\n _drawfill(chart.ctx, source, chart.chartArea);\n }\n }\n },\n beforeDatasetDraw(chart, args, options) {\n const source = args.meta.$filler;\n if (!source || source.fill === false || options.drawTime !== 'beforeDatasetDraw') {\n return;\n }\n _drawfill(chart.ctx, source, chart.chartArea);\n },\n defaults: {\n propagate: true,\n drawTime: 'beforeDatasetDraw'\n }\n};\n\nconst getBoxSize = (labelOpts, fontSize) => {\n let {boxHeight = fontSize, boxWidth = fontSize} = labelOpts;\n if (labelOpts.usePointStyle) {\n boxHeight = Math.min(boxHeight, fontSize);\n boxWidth = Math.min(boxWidth, fontSize);\n }\n return {\n boxWidth,\n boxHeight,\n itemHeight: Math.max(fontSize, boxHeight)\n };\n};\nconst itemsEqual = (a, b) => a !== null && b !== null && a.datasetIndex === b.datasetIndex && a.index === b.index;\nclass Legend extends Element {\n constructor(config) {\n super();\n this._added = false;\n this.legendHitBoxes = [];\n this._hoveredItem = null;\n this.doughnutMode = false;\n this.chart = config.chart;\n this.options = config.options;\n this.ctx = config.ctx;\n this.legendItems = undefined;\n this.columnSizes = undefined;\n this.lineWidths = undefined;\n this.maxHeight = undefined;\n this.maxWidth = undefined;\n this.top = undefined;\n this.bottom = undefined;\n this.left = undefined;\n this.right = undefined;\n this.height = undefined;\n this.width = undefined;\n this._margins = undefined;\n this.position = undefined;\n this.weight = undefined;\n this.fullSize = undefined;\n }\n update(maxWidth, maxHeight, margins) {\n this.maxWidth = maxWidth;\n this.maxHeight = maxHeight;\n this._margins = margins;\n this.setDimensions();\n this.buildLabels();\n this.fit();\n }\n setDimensions() {\n if (this.isHorizontal()) {\n this.width = this.maxWidth;\n this.left = this._margins.left;\n this.right = this.width;\n } else {\n this.height = this.maxHeight;\n this.top = this._margins.top;\n this.bottom = this.height;\n }\n }\n buildLabels() {\n const labelOpts = this.options.labels || {};\n let legendItems = callback(labelOpts.generateLabels, [this.chart], this) || [];\n if (labelOpts.filter) {\n legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data));\n }\n if (labelOpts.sort) {\n legendItems = legendItems.sort((a, b) => labelOpts.sort(a, b, this.chart.data));\n }\n if (this.options.reverse) {\n legendItems.reverse();\n }\n this.legendItems = legendItems;\n }\n fit() {\n const {options, ctx} = this;\n if (!options.display) {\n this.width = this.height = 0;\n return;\n }\n const labelOpts = options.labels;\n const labelFont = toFont(labelOpts.font);\n const fontSize = labelFont.size;\n const titleHeight = this._computeTitleHeight();\n const {boxWidth, itemHeight} = getBoxSize(labelOpts, fontSize);\n let width, height;\n ctx.font = labelFont.string;\n if (this.isHorizontal()) {\n width = this.maxWidth;\n height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10;\n } else {\n height = this.maxHeight;\n width = this._fitCols(titleHeight, fontSize, boxWidth, itemHeight) + 10;\n }\n this.width = Math.min(width, options.maxWidth || this.maxWidth);\n this.height = Math.min(height, options.maxHeight || this.maxHeight);\n }\n _fitRows(titleHeight, fontSize, boxWidth, itemHeight) {\n const {ctx, maxWidth, options: {labels: {padding}}} = this;\n const hitboxes = this.legendHitBoxes = [];\n const lineWidths = this.lineWidths = [0];\n const lineHeight = itemHeight + padding;\n let totalHeight = titleHeight;\n ctx.textAlign = 'left';\n ctx.textBaseline = 'middle';\n let row = -1;\n let top = -lineHeight;\n this.legendItems.forEach((legendItem, i) => {\n const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;\n if (i === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) {\n totalHeight += lineHeight;\n lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0;\n top += lineHeight;\n row++;\n }\n hitboxes[i] = {left: 0, top, row, width: itemWidth, height: itemHeight};\n lineWidths[lineWidths.length - 1] += itemWidth + padding;\n });\n return totalHeight;\n }\n _fitCols(titleHeight, fontSize, boxWidth, itemHeight) {\n const {ctx, maxHeight, options: {labels: {padding}}} = this;\n const hitboxes = this.legendHitBoxes = [];\n const columnSizes = this.columnSizes = [];\n const heightLimit = maxHeight - titleHeight;\n let totalWidth = padding;\n let currentColWidth = 0;\n let currentColHeight = 0;\n let left = 0;\n let col = 0;\n this.legendItems.forEach((legendItem, i) => {\n const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;\n if (i > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) {\n totalWidth += currentColWidth + padding;\n columnSizes.push({width: currentColWidth, height: currentColHeight});\n left += currentColWidth + padding;\n col++;\n currentColWidth = currentColHeight = 0;\n }\n hitboxes[i] = {left, top: currentColHeight, col, width: itemWidth, height: itemHeight};\n currentColWidth = Math.max(currentColWidth, itemWidth);\n currentColHeight += itemHeight + padding;\n });\n totalWidth += currentColWidth;\n columnSizes.push({width: currentColWidth, height: currentColHeight});\n return totalWidth;\n }\n adjustHitBoxes() {\n if (!this.options.display) {\n return;\n }\n const titleHeight = this._computeTitleHeight();\n const {legendHitBoxes: hitboxes, options: {align, labels: {padding}, rtl}} = this;\n const rtlHelper = getRtlAdapter(rtl, this.left, this.width);\n if (this.isHorizontal()) {\n let row = 0;\n let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);\n for (const hitbox of hitboxes) {\n if (row !== hitbox.row) {\n row = hitbox.row;\n left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);\n }\n hitbox.top += this.top + titleHeight + padding;\n hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width);\n left += hitbox.width + padding;\n }\n } else {\n let col = 0;\n let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);\n for (const hitbox of hitboxes) {\n if (hitbox.col !== col) {\n col = hitbox.col;\n top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);\n }\n hitbox.top = top;\n hitbox.left += this.left + padding;\n hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width);\n top += hitbox.height + padding;\n }\n }\n }\n isHorizontal() {\n return this.options.position === 'top' || this.options.position === 'bottom';\n }\n draw() {\n if (this.options.display) {\n const ctx = this.ctx;\n clipArea(ctx, this);\n this._draw();\n unclipArea(ctx);\n }\n }\n _draw() {\n const {options: opts, columnSizes, lineWidths, ctx} = this;\n const {align, labels: labelOpts} = opts;\n const defaultColor = defaults.color;\n const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);\n const labelFont = toFont(labelOpts.font);\n const {color: fontColor, padding} = labelOpts;\n const fontSize = labelFont.size;\n const halfFontSize = fontSize / 2;\n let cursor;\n this.drawTitle();\n ctx.textAlign = rtlHelper.textAlign('left');\n ctx.textBaseline = 'middle';\n ctx.lineWidth = 0.5;\n ctx.font = labelFont.string;\n const {boxWidth, boxHeight, itemHeight} = getBoxSize(labelOpts, fontSize);\n const drawLegendBox = function(x, y, legendItem) {\n if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) {\n return;\n }\n ctx.save();\n const lineWidth = valueOrDefault(legendItem.lineWidth, 1);\n ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor);\n ctx.lineCap = valueOrDefault(legendItem.lineCap, 'butt');\n ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0);\n ctx.lineJoin = valueOrDefault(legendItem.lineJoin, 'miter');\n ctx.lineWidth = lineWidth;\n ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor);\n ctx.setLineDash(valueOrDefault(legendItem.lineDash, []));\n if (labelOpts.usePointStyle) {\n const drawOptions = {\n radius: boxWidth * Math.SQRT2 / 2,\n pointStyle: legendItem.pointStyle,\n rotation: legendItem.rotation,\n borderWidth: lineWidth\n };\n const centerX = rtlHelper.xPlus(x, boxWidth / 2);\n const centerY = y + halfFontSize;\n drawPoint(ctx, drawOptions, centerX, centerY);\n } else {\n const yBoxTop = y + Math.max((fontSize - boxHeight) / 2, 0);\n const xBoxLeft = rtlHelper.leftForLtr(x, boxWidth);\n const borderRadius = toTRBLCorners(legendItem.borderRadius);\n ctx.beginPath();\n if (Object.values(borderRadius).some(v => v !== 0)) {\n addRoundedRectPath(ctx, {\n x: xBoxLeft,\n y: yBoxTop,\n w: boxWidth,\n h: boxHeight,\n radius: borderRadius,\n });\n } else {\n ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight);\n }\n ctx.fill();\n if (lineWidth !== 0) {\n ctx.stroke();\n }\n }\n ctx.restore();\n };\n const fillText = function(x, y, legendItem) {\n renderText(ctx, legendItem.text, x, y + (itemHeight / 2), labelFont, {\n strikethrough: legendItem.hidden,\n textAlign: rtlHelper.textAlign(legendItem.textAlign)\n });\n };\n const isHorizontal = this.isHorizontal();\n const titleHeight = this._computeTitleHeight();\n if (isHorizontal) {\n cursor = {\n x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]),\n y: this.top + padding + titleHeight,\n line: 0\n };\n } else {\n cursor = {\n x: this.left + padding,\n y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height),\n line: 0\n };\n }\n overrideTextDirection(this.ctx, opts.textDirection);\n const lineHeight = itemHeight + padding;\n this.legendItems.forEach((legendItem, i) => {\n ctx.strokeStyle = legendItem.fontColor || fontColor;\n ctx.fillStyle = legendItem.fontColor || fontColor;\n const textWidth = ctx.measureText(legendItem.text).width;\n const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign));\n const width = boxWidth + halfFontSize + textWidth;\n let x = cursor.x;\n let y = cursor.y;\n rtlHelper.setWidth(this.width);\n if (isHorizontal) {\n if (i > 0 && x + width + padding > this.right) {\n y = cursor.y += lineHeight;\n cursor.line++;\n x = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]);\n }\n } else if (i > 0 && y + lineHeight > this.bottom) {\n x = cursor.x = x + columnSizes[cursor.line].width + padding;\n cursor.line++;\n y = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height);\n }\n const realX = rtlHelper.x(x);\n drawLegendBox(realX, y, legendItem);\n x = _textX(textAlign, x + boxWidth + halfFontSize, isHorizontal ? x + width : this.right, opts.rtl);\n fillText(rtlHelper.x(x), y, legendItem);\n if (isHorizontal) {\n cursor.x += width + padding;\n } else {\n cursor.y += lineHeight;\n }\n });\n restoreTextDirection(this.ctx, opts.textDirection);\n }\n drawTitle() {\n const opts = this.options;\n const titleOpts = opts.title;\n const titleFont = toFont(titleOpts.font);\n const titlePadding = toPadding(titleOpts.padding);\n if (!titleOpts.display) {\n return;\n }\n const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);\n const ctx = this.ctx;\n const position = titleOpts.position;\n const halfFontSize = titleFont.size / 2;\n const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize;\n let y;\n let left = this.left;\n let maxWidth = this.width;\n if (this.isHorizontal()) {\n maxWidth = Math.max(...this.lineWidths);\n y = this.top + topPaddingPlusHalfFontSize;\n left = _alignStartEnd(opts.align, left, this.right - maxWidth);\n } else {\n const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0);\n y = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight());\n }\n const x = _alignStartEnd(position, left, left + maxWidth);\n ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position));\n ctx.textBaseline = 'middle';\n ctx.strokeStyle = titleOpts.color;\n ctx.fillStyle = titleOpts.color;\n ctx.font = titleFont.string;\n renderText(ctx, titleOpts.text, x, y, titleFont);\n }\n _computeTitleHeight() {\n const titleOpts = this.options.title;\n const titleFont = toFont(titleOpts.font);\n const titlePadding = toPadding(titleOpts.padding);\n return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0;\n }\n _getLegendItemAt(x, y) {\n let i, hitBox, lh;\n if (_isBetween(x, this.left, this.right)\n && _isBetween(y, this.top, this.bottom)) {\n lh = this.legendHitBoxes;\n for (i = 0; i < lh.length; ++i) {\n hitBox = lh[i];\n if (_isBetween(x, hitBox.left, hitBox.left + hitBox.width)\n && _isBetween(y, hitBox.top, hitBox.top + hitBox.height)) {\n return this.legendItems[i];\n }\n }\n }\n return null;\n }\n handleEvent(e) {\n const opts = this.options;\n if (!isListened(e.type, opts)) {\n return;\n }\n const hoveredItem = this._getLegendItemAt(e.x, e.y);\n if (e.type === 'mousemove' || e.type === 'mouseout') {\n const previous = this._hoveredItem;\n const sameItem = itemsEqual(previous, hoveredItem);\n if (previous && !sameItem) {\n callback(opts.onLeave, [e, previous, this], this);\n }\n this._hoveredItem = hoveredItem;\n if (hoveredItem && !sameItem) {\n callback(opts.onHover, [e, hoveredItem, this], this);\n }\n } else if (hoveredItem) {\n callback(opts.onClick, [e, hoveredItem, this], this);\n }\n }\n}\nfunction isListened(type, opts) {\n if ((type === 'mousemove' || type === 'mouseout') && (opts.onHover || opts.onLeave)) {\n return true;\n }\n if (opts.onClick && (type === 'click' || type === 'mouseup')) {\n return true;\n }\n return false;\n}\nvar plugin_legend = {\n id: 'legend',\n _element: Legend,\n start(chart, _args, options) {\n const legend = chart.legend = new Legend({ctx: chart.ctx, options, chart});\n layouts.configure(chart, legend, options);\n layouts.addBox(chart, legend);\n },\n stop(chart) {\n layouts.removeBox(chart, chart.legend);\n delete chart.legend;\n },\n beforeUpdate(chart, _args, options) {\n const legend = chart.legend;\n layouts.configure(chart, legend, options);\n legend.options = options;\n },\n afterUpdate(chart) {\n const legend = chart.legend;\n legend.buildLabels();\n legend.adjustHitBoxes();\n },\n afterEvent(chart, args) {\n if (!args.replay) {\n chart.legend.handleEvent(args.event);\n }\n },\n defaults: {\n display: true,\n position: 'top',\n align: 'center',\n fullSize: true,\n reverse: false,\n weight: 1000,\n onClick(e, legendItem, legend) {\n const index = legendItem.datasetIndex;\n const ci = legend.chart;\n if (ci.isDatasetVisible(index)) {\n ci.hide(index);\n legendItem.hidden = true;\n } else {\n ci.show(index);\n legendItem.hidden = false;\n }\n },\n onHover: null,\n onLeave: null,\n labels: {\n color: (ctx) => ctx.chart.options.color,\n boxWidth: 40,\n padding: 10,\n generateLabels(chart) {\n const datasets = chart.data.datasets;\n const {labels: {usePointStyle, pointStyle, textAlign, color}} = chart.legend.options;\n return chart._getSortedDatasetMetas().map((meta) => {\n const style = meta.controller.getStyle(usePointStyle ? 0 : undefined);\n const borderWidth = toPadding(style.borderWidth);\n return {\n text: datasets[meta.index].label,\n fillStyle: style.backgroundColor,\n fontColor: color,\n hidden: !meta.visible,\n lineCap: style.borderCapStyle,\n lineDash: style.borderDash,\n lineDashOffset: style.borderDashOffset,\n lineJoin: style.borderJoinStyle,\n lineWidth: (borderWidth.width + borderWidth.height) / 4,\n strokeStyle: style.borderColor,\n pointStyle: pointStyle || style.pointStyle,\n rotation: style.rotation,\n textAlign: textAlign || style.textAlign,\n borderRadius: 0,\n datasetIndex: meta.index\n };\n }, this);\n }\n },\n title: {\n color: (ctx) => ctx.chart.options.color,\n display: false,\n position: 'center',\n text: '',\n }\n },\n descriptors: {\n _scriptable: (name) => !name.startsWith('on'),\n labels: {\n _scriptable: (name) => !['generateLabels', 'filter', 'sort'].includes(name),\n }\n },\n};\n\nclass Title extends Element {\n constructor(config) {\n super();\n this.chart = config.chart;\n this.options = config.options;\n this.ctx = config.ctx;\n this._padding = undefined;\n this.top = undefined;\n this.bottom = undefined;\n this.left = undefined;\n this.right = undefined;\n this.width = undefined;\n this.height = undefined;\n this.position = undefined;\n this.weight = undefined;\n this.fullSize = undefined;\n }\n update(maxWidth, maxHeight) {\n const opts = this.options;\n this.left = 0;\n this.top = 0;\n if (!opts.display) {\n this.width = this.height = this.right = this.bottom = 0;\n return;\n }\n this.width = this.right = maxWidth;\n this.height = this.bottom = maxHeight;\n const lineCount = isArray(opts.text) ? opts.text.length : 1;\n this._padding = toPadding(opts.padding);\n const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height;\n if (this.isHorizontal()) {\n this.height = textSize;\n } else {\n this.width = textSize;\n }\n }\n isHorizontal() {\n const pos = this.options.position;\n return pos === 'top' || pos === 'bottom';\n }\n _drawArgs(offset) {\n const {top, left, bottom, right, options} = this;\n const align = options.align;\n let rotation = 0;\n let maxWidth, titleX, titleY;\n if (this.isHorizontal()) {\n titleX = _alignStartEnd(align, left, right);\n titleY = top + offset;\n maxWidth = right - left;\n } else {\n if (options.position === 'left') {\n titleX = left + offset;\n titleY = _alignStartEnd(align, bottom, top);\n rotation = PI * -0.5;\n } else {\n titleX = right - offset;\n titleY = _alignStartEnd(align, top, bottom);\n rotation = PI * 0.5;\n }\n maxWidth = bottom - top;\n }\n return {titleX, titleY, maxWidth, rotation};\n }\n draw() {\n const ctx = this.ctx;\n const opts = this.options;\n if (!opts.display) {\n return;\n }\n const fontOpts = toFont(opts.font);\n const lineHeight = fontOpts.lineHeight;\n const offset = lineHeight / 2 + this._padding.top;\n const {titleX, titleY, maxWidth, rotation} = this._drawArgs(offset);\n renderText(ctx, opts.text, 0, 0, fontOpts, {\n color: opts.color,\n maxWidth,\n rotation,\n textAlign: _toLeftRightCenter(opts.align),\n textBaseline: 'middle',\n translation: [titleX, titleY],\n });\n }\n}\nfunction createTitle(chart, titleOpts) {\n const title = new Title({\n ctx: chart.ctx,\n options: titleOpts,\n chart\n });\n layouts.configure(chart, title, titleOpts);\n layouts.addBox(chart, title);\n chart.titleBlock = title;\n}\nvar plugin_title = {\n id: 'title',\n _element: Title,\n start(chart, _args, options) {\n createTitle(chart, options);\n },\n stop(chart) {\n const titleBlock = chart.titleBlock;\n layouts.removeBox(chart, titleBlock);\n delete chart.titleBlock;\n },\n beforeUpdate(chart, _args, options) {\n const title = chart.titleBlock;\n layouts.configure(chart, title, options);\n title.options = options;\n },\n defaults: {\n align: 'center',\n display: false,\n font: {\n weight: 'bold',\n },\n fullSize: true,\n padding: 10,\n position: 'top',\n text: '',\n weight: 2000\n },\n defaultRoutes: {\n color: 'color'\n },\n descriptors: {\n _scriptable: true,\n _indexable: false,\n },\n};\n\nconst map = new WeakMap();\nvar plugin_subtitle = {\n id: 'subtitle',\n start(chart, _args, options) {\n const title = new Title({\n ctx: chart.ctx,\n options,\n chart\n });\n layouts.configure(chart, title, options);\n layouts.addBox(chart, title);\n map.set(chart, title);\n },\n stop(chart) {\n layouts.removeBox(chart, map.get(chart));\n map.delete(chart);\n },\n beforeUpdate(chart, _args, options) {\n const title = map.get(chart);\n layouts.configure(chart, title, options);\n title.options = options;\n },\n defaults: {\n align: 'center',\n display: false,\n font: {\n weight: 'normal',\n },\n fullSize: true,\n padding: 0,\n position: 'top',\n text: '',\n weight: 1500\n },\n defaultRoutes: {\n color: 'color'\n },\n descriptors: {\n _scriptable: true,\n _indexable: false,\n },\n};\n\nconst positioners = {\n average(items) {\n if (!items.length) {\n return false;\n }\n let i, len;\n let x = 0;\n let y = 0;\n let count = 0;\n for (i = 0, len = items.length; i < len; ++i) {\n const el = items[i].element;\n if (el && el.hasValue()) {\n const pos = el.tooltipPosition();\n x += pos.x;\n y += pos.y;\n ++count;\n }\n }\n return {\n x: x / count,\n y: y / count\n };\n },\n nearest(items, eventPosition) {\n if (!items.length) {\n return false;\n }\n let x = eventPosition.x;\n let y = eventPosition.y;\n let minDistance = Number.POSITIVE_INFINITY;\n let i, len, nearestElement;\n for (i = 0, len = items.length; i < len; ++i) {\n const el = items[i].element;\n if (el && el.hasValue()) {\n const center = el.getCenterPoint();\n const d = distanceBetweenPoints(eventPosition, center);\n if (d < minDistance) {\n minDistance = d;\n nearestElement = el;\n }\n }\n }\n if (nearestElement) {\n const tp = nearestElement.tooltipPosition();\n x = tp.x;\n y = tp.y;\n }\n return {\n x,\n y\n };\n }\n};\nfunction pushOrConcat(base, toPush) {\n if (toPush) {\n if (isArray(toPush)) {\n Array.prototype.push.apply(base, toPush);\n } else {\n base.push(toPush);\n }\n }\n return base;\n}\nfunction splitNewlines(str) {\n if ((typeof str === 'string' || str instanceof String) && str.indexOf('\\n') > -1) {\n return str.split('\\n');\n }\n return str;\n}\nfunction createTooltipItem(chart, item) {\n const {element, datasetIndex, index} = item;\n const controller = chart.getDatasetMeta(datasetIndex).controller;\n const {label, value} = controller.getLabelAndValue(index);\n return {\n chart,\n label,\n parsed: controller.getParsed(index),\n raw: chart.data.datasets[datasetIndex].data[index],\n formattedValue: value,\n dataset: controller.getDataset(),\n dataIndex: index,\n datasetIndex,\n element\n };\n}\nfunction getTooltipSize(tooltip, options) {\n const ctx = tooltip.chart.ctx;\n const {body, footer, title} = tooltip;\n const {boxWidth, boxHeight} = options;\n const bodyFont = toFont(options.bodyFont);\n const titleFont = toFont(options.titleFont);\n const footerFont = toFont(options.footerFont);\n const titleLineCount = title.length;\n const footerLineCount = footer.length;\n const bodyLineItemCount = body.length;\n const padding = toPadding(options.padding);\n let height = padding.height;\n let width = 0;\n let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);\n combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;\n if (titleLineCount) {\n height += titleLineCount * titleFont.lineHeight\n\t\t\t+ (titleLineCount - 1) * options.titleSpacing\n\t\t\t+ options.titleMarginBottom;\n }\n if (combinedBodyLength) {\n const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;\n height += bodyLineItemCount * bodyLineHeight\n\t\t\t+ (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight\n\t\t\t+ (combinedBodyLength - 1) * options.bodySpacing;\n }\n if (footerLineCount) {\n height += options.footerMarginTop\n\t\t\t+ footerLineCount * footerFont.lineHeight\n\t\t\t+ (footerLineCount - 1) * options.footerSpacing;\n }\n let widthPadding = 0;\n const maxLineWidth = function(line) {\n width = Math.max(width, ctx.measureText(line).width + widthPadding);\n };\n ctx.save();\n ctx.font = titleFont.string;\n each(tooltip.title, maxLineWidth);\n ctx.font = bodyFont.string;\n each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);\n widthPadding = options.displayColors ? (boxWidth + 2 + options.boxPadding) : 0;\n each(body, (bodyItem) => {\n each(bodyItem.before, maxLineWidth);\n each(bodyItem.lines, maxLineWidth);\n each(bodyItem.after, maxLineWidth);\n });\n widthPadding = 0;\n ctx.font = footerFont.string;\n each(tooltip.footer, maxLineWidth);\n ctx.restore();\n width += padding.width;\n return {width, height};\n}\nfunction determineYAlign(chart, size) {\n const {y, height} = size;\n if (y < height / 2) {\n return 'top';\n } else if (y > (chart.height - height / 2)) {\n return 'bottom';\n }\n return 'center';\n}\nfunction doesNotFitWithAlign(xAlign, chart, options, size) {\n const {x, width} = size;\n const caret = options.caretSize + options.caretPadding;\n if (xAlign === 'left' && x + width + caret > chart.width) {\n return true;\n }\n if (xAlign === 'right' && x - width - caret < 0) {\n return true;\n }\n}\nfunction determineXAlign(chart, options, size, yAlign) {\n const {x, width} = size;\n const {width: chartWidth, chartArea: {left, right}} = chart;\n let xAlign = 'center';\n if (yAlign === 'center') {\n xAlign = x <= (left + right) / 2 ? 'left' : 'right';\n } else if (x <= width / 2) {\n xAlign = 'left';\n } else if (x >= chartWidth - width / 2) {\n xAlign = 'right';\n }\n if (doesNotFitWithAlign(xAlign, chart, options, size)) {\n xAlign = 'center';\n }\n return xAlign;\n}\nfunction determineAlignment(chart, options, size) {\n const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);\n return {\n xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),\n yAlign\n };\n}\nfunction alignX(size, xAlign) {\n let {x, width} = size;\n if (xAlign === 'right') {\n x -= width;\n } else if (xAlign === 'center') {\n x -= (width / 2);\n }\n return x;\n}\nfunction alignY(size, yAlign, paddingAndSize) {\n let {y, height} = size;\n if (yAlign === 'top') {\n y += paddingAndSize;\n } else if (yAlign === 'bottom') {\n y -= height + paddingAndSize;\n } else {\n y -= (height / 2);\n }\n return y;\n}\nfunction getBackgroundPoint(options, size, alignment, chart) {\n const {caretSize, caretPadding, cornerRadius} = options;\n const {xAlign, yAlign} = alignment;\n const paddingAndSize = caretSize + caretPadding;\n const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);\n let x = alignX(size, xAlign);\n const y = alignY(size, yAlign, paddingAndSize);\n if (yAlign === 'center') {\n if (xAlign === 'left') {\n x += paddingAndSize;\n } else if (xAlign === 'right') {\n x -= paddingAndSize;\n }\n } else if (xAlign === 'left') {\n x -= Math.max(topLeft, bottomLeft) + caretSize;\n } else if (xAlign === 'right') {\n x += Math.max(topRight, bottomRight) + caretSize;\n }\n return {\n x: _limitValue(x, 0, chart.width - size.width),\n y: _limitValue(y, 0, chart.height - size.height)\n };\n}\nfunction getAlignedX(tooltip, align, options) {\n const padding = toPadding(options.padding);\n return align === 'center'\n ? tooltip.x + tooltip.width / 2\n : align === 'right'\n ? tooltip.x + tooltip.width - padding.right\n : tooltip.x + padding.left;\n}\nfunction getBeforeAfterBodyLines(callback) {\n return pushOrConcat([], splitNewlines(callback));\n}\nfunction createTooltipContext(parent, tooltip, tooltipItems) {\n return createContext(parent, {\n tooltip,\n tooltipItems,\n type: 'tooltip'\n });\n}\nfunction overrideCallbacks(callbacks, context) {\n const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;\n return override ? callbacks.override(override) : callbacks;\n}\nclass Tooltip extends Element {\n constructor(config) {\n super();\n this.opacity = 0;\n this._active = [];\n this._eventPosition = undefined;\n this._size = undefined;\n this._cachedAnimations = undefined;\n this._tooltipItems = [];\n this.$animations = undefined;\n this.$context = undefined;\n this.chart = config.chart || config._chart;\n this._chart = this.chart;\n this.options = config.options;\n this.dataPoints = undefined;\n this.title = undefined;\n this.beforeBody = undefined;\n this.body = undefined;\n this.afterBody = undefined;\n this.footer = undefined;\n this.xAlign = undefined;\n this.yAlign = undefined;\n this.x = undefined;\n this.y = undefined;\n this.height = undefined;\n this.width = undefined;\n this.caretX = undefined;\n this.caretY = undefined;\n this.labelColors = undefined;\n this.labelPointStyles = undefined;\n this.labelTextColors = undefined;\n }\n initialize(options) {\n this.options = options;\n this._cachedAnimations = undefined;\n this.$context = undefined;\n }\n _resolveAnimations() {\n const cached = this._cachedAnimations;\n if (cached) {\n return cached;\n }\n const chart = this.chart;\n const options = this.options.setContext(this.getContext());\n const opts = options.enabled && chart.options.animation && options.animations;\n const animations = new Animations(this.chart, opts);\n if (opts._cacheable) {\n this._cachedAnimations = Object.freeze(animations);\n }\n return animations;\n }\n getContext() {\n return this.$context ||\n\t\t\t(this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));\n }\n getTitle(context, options) {\n const {callbacks} = options;\n const beforeTitle = callbacks.beforeTitle.apply(this, [context]);\n const title = callbacks.title.apply(this, [context]);\n const afterTitle = callbacks.afterTitle.apply(this, [context]);\n let lines = [];\n lines = pushOrConcat(lines, splitNewlines(beforeTitle));\n lines = pushOrConcat(lines, splitNewlines(title));\n lines = pushOrConcat(lines, splitNewlines(afterTitle));\n return lines;\n }\n getBeforeBody(tooltipItems, options) {\n return getBeforeAfterBodyLines(options.callbacks.beforeBody.apply(this, [tooltipItems]));\n }\n getBody(tooltipItems, options) {\n const {callbacks} = options;\n const bodyItems = [];\n each(tooltipItems, (context) => {\n const bodyItem = {\n before: [],\n lines: [],\n after: []\n };\n const scoped = overrideCallbacks(callbacks, context);\n pushOrConcat(bodyItem.before, splitNewlines(scoped.beforeLabel.call(this, context)));\n pushOrConcat(bodyItem.lines, scoped.label.call(this, context));\n pushOrConcat(bodyItem.after, splitNewlines(scoped.afterLabel.call(this, context)));\n bodyItems.push(bodyItem);\n });\n return bodyItems;\n }\n getAfterBody(tooltipItems, options) {\n return getBeforeAfterBodyLines(options.callbacks.afterBody.apply(this, [tooltipItems]));\n }\n getFooter(tooltipItems, options) {\n const {callbacks} = options;\n const beforeFooter = callbacks.beforeFooter.apply(this, [tooltipItems]);\n const footer = callbacks.footer.apply(this, [tooltipItems]);\n const afterFooter = callbacks.afterFooter.apply(this, [tooltipItems]);\n let lines = [];\n lines = pushOrConcat(lines, splitNewlines(beforeFooter));\n lines = pushOrConcat(lines, splitNewlines(footer));\n lines = pushOrConcat(lines, splitNewlines(afterFooter));\n return lines;\n }\n _createItems(options) {\n const active = this._active;\n const data = this.chart.data;\n const labelColors = [];\n const labelPointStyles = [];\n const labelTextColors = [];\n let tooltipItems = [];\n let i, len;\n for (i = 0, len = active.length; i < len; ++i) {\n tooltipItems.push(createTooltipItem(this.chart, active[i]));\n }\n if (options.filter) {\n tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));\n }\n if (options.itemSort) {\n tooltipItems = tooltipItems.sort((a, b) => options.itemSort(a, b, data));\n }\n each(tooltipItems, (context) => {\n const scoped = overrideCallbacks(options.callbacks, context);\n labelColors.push(scoped.labelColor.call(this, context));\n labelPointStyles.push(scoped.labelPointStyle.call(this, context));\n labelTextColors.push(scoped.labelTextColor.call(this, context));\n });\n this.labelColors = labelColors;\n this.labelPointStyles = labelPointStyles;\n this.labelTextColors = labelTextColors;\n this.dataPoints = tooltipItems;\n return tooltipItems;\n }\n update(changed, replay) {\n const options = this.options.setContext(this.getContext());\n const active = this._active;\n let properties;\n let tooltipItems = [];\n if (!active.length) {\n if (this.opacity !== 0) {\n properties = {\n opacity: 0\n };\n }\n } else {\n const position = positioners[options.position].call(this, active, this._eventPosition);\n tooltipItems = this._createItems(options);\n this.title = this.getTitle(tooltipItems, options);\n this.beforeBody = this.getBeforeBody(tooltipItems, options);\n this.body = this.getBody(tooltipItems, options);\n this.afterBody = this.getAfterBody(tooltipItems, options);\n this.footer = this.getFooter(tooltipItems, options);\n const size = this._size = getTooltipSize(this, options);\n const positionAndSize = Object.assign({}, position, size);\n const alignment = determineAlignment(this.chart, options, positionAndSize);\n const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);\n this.xAlign = alignment.xAlign;\n this.yAlign = alignment.yAlign;\n properties = {\n opacity: 1,\n x: backgroundPoint.x,\n y: backgroundPoint.y,\n width: size.width,\n height: size.height,\n caretX: position.x,\n caretY: position.y\n };\n }\n this._tooltipItems = tooltipItems;\n this.$context = undefined;\n if (properties) {\n this._resolveAnimations().update(this, properties);\n }\n if (changed && options.external) {\n options.external.call(this, {chart: this.chart, tooltip: this, replay});\n }\n }\n drawCaret(tooltipPoint, ctx, size, options) {\n const caretPosition = this.getCaretPosition(tooltipPoint, size, options);\n ctx.lineTo(caretPosition.x1, caretPosition.y1);\n ctx.lineTo(caretPosition.x2, caretPosition.y2);\n ctx.lineTo(caretPosition.x3, caretPosition.y3);\n }\n getCaretPosition(tooltipPoint, size, options) {\n const {xAlign, yAlign} = this;\n const {caretSize, cornerRadius} = options;\n const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);\n const {x: ptX, y: ptY} = tooltipPoint;\n const {width, height} = size;\n let x1, x2, x3, y1, y2, y3;\n if (yAlign === 'center') {\n y2 = ptY + (height / 2);\n if (xAlign === 'left') {\n x1 = ptX;\n x2 = x1 - caretSize;\n y1 = y2 + caretSize;\n y3 = y2 - caretSize;\n } else {\n x1 = ptX + width;\n x2 = x1 + caretSize;\n y1 = y2 - caretSize;\n y3 = y2 + caretSize;\n }\n x3 = x1;\n } else {\n if (xAlign === 'left') {\n x2 = ptX + Math.max(topLeft, bottomLeft) + (caretSize);\n } else if (xAlign === 'right') {\n x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;\n } else {\n x2 = this.caretX;\n }\n if (yAlign === 'top') {\n y1 = ptY;\n y2 = y1 - caretSize;\n x1 = x2 - caretSize;\n x3 = x2 + caretSize;\n } else {\n y1 = ptY + height;\n y2 = y1 + caretSize;\n x1 = x2 + caretSize;\n x3 = x2 - caretSize;\n }\n y3 = y1;\n }\n return {x1, x2, x3, y1, y2, y3};\n }\n drawTitle(pt, ctx, options) {\n const title = this.title;\n const length = title.length;\n let titleFont, titleSpacing, i;\n if (length) {\n const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n pt.x = getAlignedX(this, options.titleAlign, options);\n ctx.textAlign = rtlHelper.textAlign(options.titleAlign);\n ctx.textBaseline = 'middle';\n titleFont = toFont(options.titleFont);\n titleSpacing = options.titleSpacing;\n ctx.fillStyle = options.titleColor;\n ctx.font = titleFont.string;\n for (i = 0; i < length; ++i) {\n ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2);\n pt.y += titleFont.lineHeight + titleSpacing;\n if (i + 1 === length) {\n pt.y += options.titleMarginBottom - titleSpacing;\n }\n }\n }\n }\n _drawColorBox(ctx, pt, i, rtlHelper, options) {\n const labelColors = this.labelColors[i];\n const labelPointStyle = this.labelPointStyles[i];\n const {boxHeight, boxWidth, boxPadding} = options;\n const bodyFont = toFont(options.bodyFont);\n const colorX = getAlignedX(this, 'left', options);\n const rtlColorX = rtlHelper.x(colorX);\n const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;\n const colorY = pt.y + yOffSet;\n if (options.usePointStyle) {\n const drawOptions = {\n radius: Math.min(boxWidth, boxHeight) / 2,\n pointStyle: labelPointStyle.pointStyle,\n rotation: labelPointStyle.rotation,\n borderWidth: 1\n };\n const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;\n const centerY = colorY + boxHeight / 2;\n ctx.strokeStyle = options.multiKeyBackground;\n ctx.fillStyle = options.multiKeyBackground;\n drawPoint(ctx, drawOptions, centerX, centerY);\n ctx.strokeStyle = labelColors.borderColor;\n ctx.fillStyle = labelColors.backgroundColor;\n drawPoint(ctx, drawOptions, centerX, centerY);\n } else {\n ctx.lineWidth = labelColors.borderWidth || 1;\n ctx.strokeStyle = labelColors.borderColor;\n ctx.setLineDash(labelColors.borderDash || []);\n ctx.lineDashOffset = labelColors.borderDashOffset || 0;\n const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth - boxPadding);\n const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - boxPadding - 2);\n const borderRadius = toTRBLCorners(labelColors.borderRadius);\n if (Object.values(borderRadius).some(v => v !== 0)) {\n ctx.beginPath();\n ctx.fillStyle = options.multiKeyBackground;\n addRoundedRectPath(ctx, {\n x: outerX,\n y: colorY,\n w: boxWidth,\n h: boxHeight,\n radius: borderRadius,\n });\n ctx.fill();\n ctx.stroke();\n ctx.fillStyle = labelColors.backgroundColor;\n ctx.beginPath();\n addRoundedRectPath(ctx, {\n x: innerX,\n y: colorY + 1,\n w: boxWidth - 2,\n h: boxHeight - 2,\n radius: borderRadius,\n });\n ctx.fill();\n } else {\n ctx.fillStyle = options.multiKeyBackground;\n ctx.fillRect(outerX, colorY, boxWidth, boxHeight);\n ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);\n ctx.fillStyle = labelColors.backgroundColor;\n ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);\n }\n }\n ctx.fillStyle = this.labelTextColors[i];\n }\n drawBody(pt, ctx, options) {\n const {body} = this;\n const {bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding} = options;\n const bodyFont = toFont(options.bodyFont);\n let bodyLineHeight = bodyFont.lineHeight;\n let xLinePadding = 0;\n const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n const fillLineOfText = function(line) {\n ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2);\n pt.y += bodyLineHeight + bodySpacing;\n };\n const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);\n let bodyItem, textColor, lines, i, j, ilen, jlen;\n ctx.textAlign = bodyAlign;\n ctx.textBaseline = 'middle';\n ctx.font = bodyFont.string;\n pt.x = getAlignedX(this, bodyAlignForCalculation, options);\n ctx.fillStyle = options.bodyColor;\n each(this.beforeBody, fillLineOfText);\n xLinePadding = displayColors && bodyAlignForCalculation !== 'right'\n ? bodyAlign === 'center' ? (boxWidth / 2 + boxPadding) : (boxWidth + 2 + boxPadding)\n : 0;\n for (i = 0, ilen = body.length; i < ilen; ++i) {\n bodyItem = body[i];\n textColor = this.labelTextColors[i];\n ctx.fillStyle = textColor;\n each(bodyItem.before, fillLineOfText);\n lines = bodyItem.lines;\n if (displayColors && lines.length) {\n this._drawColorBox(ctx, pt, i, rtlHelper, options);\n bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);\n }\n for (j = 0, jlen = lines.length; j < jlen; ++j) {\n fillLineOfText(lines[j]);\n bodyLineHeight = bodyFont.lineHeight;\n }\n each(bodyItem.after, fillLineOfText);\n }\n xLinePadding = 0;\n bodyLineHeight = bodyFont.lineHeight;\n each(this.afterBody, fillLineOfText);\n pt.y -= bodySpacing;\n }\n drawFooter(pt, ctx, options) {\n const footer = this.footer;\n const length = footer.length;\n let footerFont, i;\n if (length) {\n const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n pt.x = getAlignedX(this, options.footerAlign, options);\n pt.y += options.footerMarginTop;\n ctx.textAlign = rtlHelper.textAlign(options.footerAlign);\n ctx.textBaseline = 'middle';\n footerFont = toFont(options.footerFont);\n ctx.fillStyle = options.footerColor;\n ctx.font = footerFont.string;\n for (i = 0; i < length; ++i) {\n ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2);\n pt.y += footerFont.lineHeight + options.footerSpacing;\n }\n }\n }\n drawBackground(pt, ctx, tooltipSize, options) {\n const {xAlign, yAlign} = this;\n const {x, y} = pt;\n const {width, height} = tooltipSize;\n const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(options.cornerRadius);\n ctx.fillStyle = options.backgroundColor;\n ctx.strokeStyle = options.borderColor;\n ctx.lineWidth = options.borderWidth;\n ctx.beginPath();\n ctx.moveTo(x + topLeft, y);\n if (yAlign === 'top') {\n this.drawCaret(pt, ctx, tooltipSize, options);\n }\n ctx.lineTo(x + width - topRight, y);\n ctx.quadraticCurveTo(x + width, y, x + width, y + topRight);\n if (yAlign === 'center' && xAlign === 'right') {\n this.drawCaret(pt, ctx, tooltipSize, options);\n }\n ctx.lineTo(x + width, y + height - bottomRight);\n ctx.quadraticCurveTo(x + width, y + height, x + width - bottomRight, y + height);\n if (yAlign === 'bottom') {\n this.drawCaret(pt, ctx, tooltipSize, options);\n }\n ctx.lineTo(x + bottomLeft, y + height);\n ctx.quadraticCurveTo(x, y + height, x, y + height - bottomLeft);\n if (yAlign === 'center' && xAlign === 'left') {\n this.drawCaret(pt, ctx, tooltipSize, options);\n }\n ctx.lineTo(x, y + topLeft);\n ctx.quadraticCurveTo(x, y, x + topLeft, y);\n ctx.closePath();\n ctx.fill();\n if (options.borderWidth > 0) {\n ctx.stroke();\n }\n }\n _updateAnimationTarget(options) {\n const chart = this.chart;\n const anims = this.$animations;\n const animX = anims && anims.x;\n const animY = anims && anims.y;\n if (animX || animY) {\n const position = positioners[options.position].call(this, this._active, this._eventPosition);\n if (!position) {\n return;\n }\n const size = this._size = getTooltipSize(this, options);\n const positionAndSize = Object.assign({}, position, this._size);\n const alignment = determineAlignment(chart, options, positionAndSize);\n const point = getBackgroundPoint(options, positionAndSize, alignment, chart);\n if (animX._to !== point.x || animY._to !== point.y) {\n this.xAlign = alignment.xAlign;\n this.yAlign = alignment.yAlign;\n this.width = size.width;\n this.height = size.height;\n this.caretX = position.x;\n this.caretY = position.y;\n this._resolveAnimations().update(this, point);\n }\n }\n }\n _willRender() {\n return !!this.opacity;\n }\n draw(ctx) {\n const options = this.options.setContext(this.getContext());\n let opacity = this.opacity;\n if (!opacity) {\n return;\n }\n this._updateAnimationTarget(options);\n const tooltipSize = {\n width: this.width,\n height: this.height\n };\n const pt = {\n x: this.x,\n y: this.y\n };\n opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;\n const padding = toPadding(options.padding);\n const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;\n if (options.enabled && hasTooltipContent) {\n ctx.save();\n ctx.globalAlpha = opacity;\n this.drawBackground(pt, ctx, tooltipSize, options);\n overrideTextDirection(ctx, options.textDirection);\n pt.y += padding.top;\n this.drawTitle(pt, ctx, options);\n this.drawBody(pt, ctx, options);\n this.drawFooter(pt, ctx, options);\n restoreTextDirection(ctx, options.textDirection);\n ctx.restore();\n }\n }\n getActiveElements() {\n return this._active || [];\n }\n setActiveElements(activeElements, eventPosition) {\n const lastActive = this._active;\n const active = activeElements.map(({datasetIndex, index}) => {\n const meta = this.chart.getDatasetMeta(datasetIndex);\n if (!meta) {\n throw new Error('Cannot find a dataset at index ' + datasetIndex);\n }\n return {\n datasetIndex,\n element: meta.data[index],\n index,\n };\n });\n const changed = !_elementsEqual(lastActive, active);\n const positionChanged = this._positionChanged(active, eventPosition);\n if (changed || positionChanged) {\n this._active = active;\n this._eventPosition = eventPosition;\n this._ignoreReplayEvents = true;\n this.update(true);\n }\n }\n handleEvent(e, replay, inChartArea = true) {\n if (replay && this._ignoreReplayEvents) {\n return false;\n }\n this._ignoreReplayEvents = false;\n const options = this.options;\n const lastActive = this._active || [];\n const active = this._getActiveElements(e, lastActive, replay, inChartArea);\n const positionChanged = this._positionChanged(active, e);\n const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;\n if (changed) {\n this._active = active;\n if (options.enabled || options.external) {\n this._eventPosition = {\n x: e.x,\n y: e.y\n };\n this.update(true, replay);\n }\n }\n return changed;\n }\n _getActiveElements(e, lastActive, replay, inChartArea) {\n const options = this.options;\n if (e.type === 'mouseout') {\n return [];\n }\n if (!inChartArea) {\n return lastActive;\n }\n const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay);\n if (options.reverse) {\n active.reverse();\n }\n return active;\n }\n _positionChanged(active, e) {\n const {caretX, caretY, options} = this;\n const position = positioners[options.position].call(this, active, e);\n return position !== false && (caretX !== position.x || caretY !== position.y);\n }\n}\nTooltip.positioners = positioners;\nvar plugin_tooltip = {\n id: 'tooltip',\n _element: Tooltip,\n positioners,\n afterInit(chart, _args, options) {\n if (options) {\n chart.tooltip = new Tooltip({chart, options});\n }\n },\n beforeUpdate(chart, _args, options) {\n if (chart.tooltip) {\n chart.tooltip.initialize(options);\n }\n },\n reset(chart, _args, options) {\n if (chart.tooltip) {\n chart.tooltip.initialize(options);\n }\n },\n afterDraw(chart) {\n const tooltip = chart.tooltip;\n if (tooltip && tooltip._willRender()) {\n const args = {\n tooltip\n };\n if (chart.notifyPlugins('beforeTooltipDraw', args) === false) {\n return;\n }\n tooltip.draw(chart.ctx);\n chart.notifyPlugins('afterTooltipDraw', args);\n }\n },\n afterEvent(chart, args) {\n if (chart.tooltip) {\n const useFinalPosition = args.replay;\n if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {\n args.changed = true;\n }\n }\n },\n defaults: {\n enabled: true,\n external: null,\n position: 'average',\n backgroundColor: 'rgba(0,0,0,0.8)',\n titleColor: '#fff',\n titleFont: {\n weight: 'bold',\n },\n titleSpacing: 2,\n titleMarginBottom: 6,\n titleAlign: 'left',\n bodyColor: '#fff',\n bodySpacing: 2,\n bodyFont: {\n },\n bodyAlign: 'left',\n footerColor: '#fff',\n footerSpacing: 2,\n footerMarginTop: 6,\n footerFont: {\n weight: 'bold',\n },\n footerAlign: 'left',\n padding: 6,\n caretPadding: 2,\n caretSize: 5,\n cornerRadius: 6,\n boxHeight: (ctx, opts) => opts.bodyFont.size,\n boxWidth: (ctx, opts) => opts.bodyFont.size,\n multiKeyBackground: '#fff',\n displayColors: true,\n boxPadding: 0,\n borderColor: 'rgba(0,0,0,0)',\n borderWidth: 0,\n animation: {\n duration: 400,\n easing: 'easeOutQuart',\n },\n animations: {\n numbers: {\n type: 'number',\n properties: ['x', 'y', 'width', 'height', 'caretX', 'caretY'],\n },\n opacity: {\n easing: 'linear',\n duration: 200\n }\n },\n callbacks: {\n beforeTitle: noop,\n title(tooltipItems) {\n if (tooltipItems.length > 0) {\n const item = tooltipItems[0];\n const labels = item.chart.data.labels;\n const labelCount = labels ? labels.length : 0;\n if (this && this.options && this.options.mode === 'dataset') {\n return item.dataset.label || '';\n } else if (item.label) {\n return item.label;\n } else if (labelCount > 0 && item.dataIndex < labelCount) {\n return labels[item.dataIndex];\n }\n }\n return '';\n },\n afterTitle: noop,\n beforeBody: noop,\n beforeLabel: noop,\n label(tooltipItem) {\n if (this && this.options && this.options.mode === 'dataset') {\n return tooltipItem.label + ': ' + tooltipItem.formattedValue || tooltipItem.formattedValue;\n }\n let label = tooltipItem.dataset.label || '';\n if (label) {\n label += ': ';\n }\n const value = tooltipItem.formattedValue;\n if (!isNullOrUndef(value)) {\n label += value;\n }\n return label;\n },\n labelColor(tooltipItem) {\n const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);\n const options = meta.controller.getStyle(tooltipItem.dataIndex);\n return {\n borderColor: options.borderColor,\n backgroundColor: options.backgroundColor,\n borderWidth: options.borderWidth,\n borderDash: options.borderDash,\n borderDashOffset: options.borderDashOffset,\n borderRadius: 0,\n };\n },\n labelTextColor() {\n return this.options.bodyColor;\n },\n labelPointStyle(tooltipItem) {\n const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);\n const options = meta.controller.getStyle(tooltipItem.dataIndex);\n return {\n pointStyle: options.pointStyle,\n rotation: options.rotation,\n };\n },\n afterLabel: noop,\n afterBody: noop,\n beforeFooter: noop,\n footer: noop,\n afterFooter: noop\n }\n },\n defaultRoutes: {\n bodyFont: 'font',\n footerFont: 'font',\n titleFont: 'font'\n },\n descriptors: {\n _scriptable: (name) => name !== 'filter' && name !== 'itemSort' && name !== 'external',\n _indexable: false,\n callbacks: {\n _scriptable: false,\n _indexable: false,\n },\n animation: {\n _fallback: false\n },\n animations: {\n _fallback: 'animation'\n }\n },\n additionalOptionScopes: ['interaction']\n};\n\nvar plugins = /*#__PURE__*/Object.freeze({\n__proto__: null,\nDecimation: plugin_decimation,\nFiller: index,\nLegend: plugin_legend,\nSubTitle: plugin_subtitle,\nTitle: plugin_title,\nTooltip: plugin_tooltip\n});\n\nconst addIfString = (labels, raw, index, addedLabels) => {\n if (typeof raw === 'string') {\n index = labels.push(raw) - 1;\n addedLabels.unshift({index, label: raw});\n } else if (isNaN(raw)) {\n index = null;\n }\n return index;\n};\nfunction findOrAddLabel(labels, raw, index, addedLabels) {\n const first = labels.indexOf(raw);\n if (first === -1) {\n return addIfString(labels, raw, index, addedLabels);\n }\n const last = labels.lastIndexOf(raw);\n return first !== last ? index : first;\n}\nconst validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max);\nclass CategoryScale extends Scale {\n constructor(cfg) {\n super(cfg);\n this._startValue = undefined;\n this._valueRange = 0;\n this._addedLabels = [];\n }\n init(scaleOptions) {\n const added = this._addedLabels;\n if (added.length) {\n const labels = this.getLabels();\n for (const {index, label} of added) {\n if (labels[index] === label) {\n labels.splice(index, 1);\n }\n }\n this._addedLabels = [];\n }\n super.init(scaleOptions);\n }\n parse(raw, index) {\n if (isNullOrUndef(raw)) {\n return null;\n }\n const labels = this.getLabels();\n index = isFinite(index) && labels[index] === raw ? index\n : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);\n return validIndex(index, labels.length - 1);\n }\n determineDataLimits() {\n const {minDefined, maxDefined} = this.getUserBounds();\n let {min, max} = this.getMinMax(true);\n if (this.options.bounds === 'ticks') {\n if (!minDefined) {\n min = 0;\n }\n if (!maxDefined) {\n max = this.getLabels().length - 1;\n }\n }\n this.min = min;\n this.max = max;\n }\n buildTicks() {\n const min = this.min;\n const max = this.max;\n const offset = this.options.offset;\n const ticks = [];\n let labels = this.getLabels();\n labels = (min === 0 && max === labels.length - 1) ? labels : labels.slice(min, max + 1);\n this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1);\n this._startValue = this.min - (offset ? 0.5 : 0);\n for (let value = min; value <= max; value++) {\n ticks.push({value});\n }\n return ticks;\n }\n getLabelForValue(value) {\n const labels = this.getLabels();\n if (value >= 0 && value < labels.length) {\n return labels[value];\n }\n return value;\n }\n configure() {\n super.configure();\n if (!this.isHorizontal()) {\n this._reversePixels = !this._reversePixels;\n }\n }\n getPixelForValue(value) {\n if (typeof value !== 'number') {\n value = this.parse(value);\n }\n return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);\n }\n getPixelForTick(index) {\n const ticks = this.ticks;\n if (index < 0 || index > ticks.length - 1) {\n return null;\n }\n return this.getPixelForValue(ticks[index].value);\n }\n getValueForPixel(pixel) {\n return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange);\n }\n getBasePixel() {\n return this.bottom;\n }\n}\nCategoryScale.id = 'category';\nCategoryScale.defaults = {\n ticks: {\n callback: CategoryScale.prototype.getLabelForValue\n }\n};\n\nfunction generateTicks$1(generationOptions, dataRange) {\n const ticks = [];\n const MIN_SPACING = 1e-14;\n const {bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds} = generationOptions;\n const unit = step || 1;\n const maxSpaces = maxTicks - 1;\n const {min: rmin, max: rmax} = dataRange;\n const minDefined = !isNullOrUndef(min);\n const maxDefined = !isNullOrUndef(max);\n const countDefined = !isNullOrUndef(count);\n const minSpacing = (rmax - rmin) / (maxDigits + 1);\n let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;\n let factor, niceMin, niceMax, numSpaces;\n if (spacing < MIN_SPACING && !minDefined && !maxDefined) {\n return [{value: rmin}, {value: rmax}];\n }\n numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);\n if (numSpaces > maxSpaces) {\n spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;\n }\n if (!isNullOrUndef(precision)) {\n factor = Math.pow(10, precision);\n spacing = Math.ceil(spacing * factor) / factor;\n }\n if (bounds === 'ticks') {\n niceMin = Math.floor(rmin / spacing) * spacing;\n niceMax = Math.ceil(rmax / spacing) * spacing;\n } else {\n niceMin = rmin;\n niceMax = rmax;\n }\n if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1000)) {\n numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));\n spacing = (max - min) / numSpaces;\n niceMin = min;\n niceMax = max;\n } else if (countDefined) {\n niceMin = minDefined ? min : niceMin;\n niceMax = maxDefined ? max : niceMax;\n numSpaces = count - 1;\n spacing = (niceMax - niceMin) / numSpaces;\n } else {\n numSpaces = (niceMax - niceMin) / spacing;\n if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {\n numSpaces = Math.round(numSpaces);\n } else {\n numSpaces = Math.ceil(numSpaces);\n }\n }\n const decimalPlaces = Math.max(\n _decimalPlaces(spacing),\n _decimalPlaces(niceMin)\n );\n factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);\n niceMin = Math.round(niceMin * factor) / factor;\n niceMax = Math.round(niceMax * factor) / factor;\n let j = 0;\n if (minDefined) {\n if (includeBounds && niceMin !== min) {\n ticks.push({value: min});\n if (niceMin < min) {\n j++;\n }\n if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {\n j++;\n }\n } else if (niceMin < min) {\n j++;\n }\n }\n for (; j < numSpaces; ++j) {\n ticks.push({value: Math.round((niceMin + j * spacing) * factor) / factor});\n }\n if (maxDefined && includeBounds && niceMax !== max) {\n if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {\n ticks[ticks.length - 1].value = max;\n } else {\n ticks.push({value: max});\n }\n } else if (!maxDefined || niceMax === max) {\n ticks.push({value: niceMax});\n }\n return ticks;\n}\nfunction relativeLabelSize(value, minSpacing, {horizontal, minRotation}) {\n const rad = toRadians(minRotation);\n const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 0.001;\n const length = 0.75 * minSpacing * ('' + value).length;\n return Math.min(minSpacing / ratio, length);\n}\nclass LinearScaleBase extends Scale {\n constructor(cfg) {\n super(cfg);\n this.start = undefined;\n this.end = undefined;\n this._startValue = undefined;\n this._endValue = undefined;\n this._valueRange = 0;\n }\n parse(raw, index) {\n if (isNullOrUndef(raw)) {\n return null;\n }\n if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) {\n return null;\n }\n return +raw;\n }\n handleTickRangeOptions() {\n const {beginAtZero} = this.options;\n const {minDefined, maxDefined} = this.getUserBounds();\n let {min, max} = this;\n const setMin = v => (min = minDefined ? min : v);\n const setMax = v => (max = maxDefined ? max : v);\n if (beginAtZero) {\n const minSign = sign(min);\n const maxSign = sign(max);\n if (minSign < 0 && maxSign < 0) {\n setMax(0);\n } else if (minSign > 0 && maxSign > 0) {\n setMin(0);\n }\n }\n if (min === max) {\n let offset = 1;\n if (max >= Number.MAX_SAFE_INTEGER || min <= Number.MIN_SAFE_INTEGER) {\n offset = Math.abs(max * 0.05);\n }\n setMax(max + offset);\n if (!beginAtZero) {\n setMin(min - offset);\n }\n }\n this.min = min;\n this.max = max;\n }\n getTickLimit() {\n const tickOpts = this.options.ticks;\n let {maxTicksLimit, stepSize} = tickOpts;\n let maxTicks;\n if (stepSize) {\n maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;\n if (maxTicks > 1000) {\n console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);\n maxTicks = 1000;\n }\n } else {\n maxTicks = this.computeTickLimit();\n maxTicksLimit = maxTicksLimit || 11;\n }\n if (maxTicksLimit) {\n maxTicks = Math.min(maxTicksLimit, maxTicks);\n }\n return maxTicks;\n }\n computeTickLimit() {\n return Number.POSITIVE_INFINITY;\n }\n buildTicks() {\n const opts = this.options;\n const tickOpts = opts.ticks;\n let maxTicks = this.getTickLimit();\n maxTicks = Math.max(2, maxTicks);\n const numericGeneratorOptions = {\n maxTicks,\n bounds: opts.bounds,\n min: opts.min,\n max: opts.max,\n precision: tickOpts.precision,\n step: tickOpts.stepSize,\n count: tickOpts.count,\n maxDigits: this._maxDigits(),\n horizontal: this.isHorizontal(),\n minRotation: tickOpts.minRotation || 0,\n includeBounds: tickOpts.includeBounds !== false\n };\n const dataRange = this._range || this;\n const ticks = generateTicks$1(numericGeneratorOptions, dataRange);\n if (opts.bounds === 'ticks') {\n _setMinAndMaxByKey(ticks, this, 'value');\n }\n if (opts.reverse) {\n ticks.reverse();\n this.start = this.max;\n this.end = this.min;\n } else {\n this.start = this.min;\n this.end = this.max;\n }\n return ticks;\n }\n configure() {\n const ticks = this.ticks;\n let start = this.min;\n let end = this.max;\n super.configure();\n if (this.options.offset && ticks.length) {\n const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;\n start -= offset;\n end += offset;\n }\n this._startValue = start;\n this._endValue = end;\n this._valueRange = end - start;\n }\n getLabelForValue(value) {\n return formatNumber(value, this.chart.options.locale, this.options.ticks.format);\n }\n}\n\nclass LinearScale extends LinearScaleBase {\n determineDataLimits() {\n const {min, max} = this.getMinMax(true);\n this.min = isNumberFinite(min) ? min : 0;\n this.max = isNumberFinite(max) ? max : 1;\n this.handleTickRangeOptions();\n }\n computeTickLimit() {\n const horizontal = this.isHorizontal();\n const length = horizontal ? this.width : this.height;\n const minRotation = toRadians(this.options.ticks.minRotation);\n const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 0.001;\n const tickFont = this._resolveTickFontOptions(0);\n return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));\n }\n getPixelForValue(value) {\n return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);\n }\n getValueForPixel(pixel) {\n return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;\n }\n}\nLinearScale.id = 'linear';\nLinearScale.defaults = {\n ticks: {\n callback: Ticks.formatters.numeric\n }\n};\n\nfunction isMajor(tickVal) {\n const remain = tickVal / (Math.pow(10, Math.floor(log10(tickVal))));\n return remain === 1;\n}\nfunction generateTicks(generationOptions, dataRange) {\n const endExp = Math.floor(log10(dataRange.max));\n const endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp));\n const ticks = [];\n let tickVal = finiteOrDefault(generationOptions.min, Math.pow(10, Math.floor(log10(dataRange.min))));\n let exp = Math.floor(log10(tickVal));\n let significand = Math.floor(tickVal / Math.pow(10, exp));\n let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;\n do {\n ticks.push({value: tickVal, major: isMajor(tickVal)});\n ++significand;\n if (significand === 10) {\n significand = 1;\n ++exp;\n precision = exp >= 0 ? 1 : precision;\n }\n tickVal = Math.round(significand * Math.pow(10, exp) * precision) / precision;\n } while (exp < endExp || (exp === endExp && significand < endSignificand));\n const lastTick = finiteOrDefault(generationOptions.max, tickVal);\n ticks.push({value: lastTick, major: isMajor(tickVal)});\n return ticks;\n}\nclass LogarithmicScale extends Scale {\n constructor(cfg) {\n super(cfg);\n this.start = undefined;\n this.end = undefined;\n this._startValue = undefined;\n this._valueRange = 0;\n }\n parse(raw, index) {\n const value = LinearScaleBase.prototype.parse.apply(this, [raw, index]);\n if (value === 0) {\n this._zero = true;\n return undefined;\n }\n return isNumberFinite(value) && value > 0 ? value : null;\n }\n determineDataLimits() {\n const {min, max} = this.getMinMax(true);\n this.min = isNumberFinite(min) ? Math.max(0, min) : null;\n this.max = isNumberFinite(max) ? Math.max(0, max) : null;\n if (this.options.beginAtZero) {\n this._zero = true;\n }\n this.handleTickRangeOptions();\n }\n handleTickRangeOptions() {\n const {minDefined, maxDefined} = this.getUserBounds();\n let min = this.min;\n let max = this.max;\n const setMin = v => (min = minDefined ? min : v);\n const setMax = v => (max = maxDefined ? max : v);\n const exp = (v, m) => Math.pow(10, Math.floor(log10(v)) + m);\n if (min === max) {\n if (min <= 0) {\n setMin(1);\n setMax(10);\n } else {\n setMin(exp(min, -1));\n setMax(exp(max, +1));\n }\n }\n if (min <= 0) {\n setMin(exp(max, -1));\n }\n if (max <= 0) {\n setMax(exp(min, +1));\n }\n if (this._zero && this.min !== this._suggestedMin && min === exp(this.min, 0)) {\n setMin(exp(min, -1));\n }\n this.min = min;\n this.max = max;\n }\n buildTicks() {\n const opts = this.options;\n const generationOptions = {\n min: this._userMin,\n max: this._userMax\n };\n const ticks = generateTicks(generationOptions, this);\n if (opts.bounds === 'ticks') {\n _setMinAndMaxByKey(ticks, this, 'value');\n }\n if (opts.reverse) {\n ticks.reverse();\n this.start = this.max;\n this.end = this.min;\n } else {\n this.start = this.min;\n this.end = this.max;\n }\n return ticks;\n }\n getLabelForValue(value) {\n return value === undefined\n ? '0'\n : formatNumber(value, this.chart.options.locale, this.options.ticks.format);\n }\n configure() {\n const start = this.min;\n super.configure();\n this._startValue = log10(start);\n this._valueRange = log10(this.max) - log10(start);\n }\n getPixelForValue(value) {\n if (value === undefined || value === 0) {\n value = this.min;\n }\n if (value === null || isNaN(value)) {\n return NaN;\n }\n return this.getPixelForDecimal(value === this.min\n ? 0\n : (log10(value) - this._startValue) / this._valueRange);\n }\n getValueForPixel(pixel) {\n const decimal = this.getDecimalForPixel(pixel);\n return Math.pow(10, this._startValue + decimal * this._valueRange);\n }\n}\nLogarithmicScale.id = 'logarithmic';\nLogarithmicScale.defaults = {\n ticks: {\n callback: Ticks.formatters.logarithmic,\n major: {\n enabled: true\n }\n }\n};\n\nfunction getTickBackdropHeight(opts) {\n const tickOpts = opts.ticks;\n if (tickOpts.display && opts.display) {\n const padding = toPadding(tickOpts.backdropPadding);\n return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + padding.height;\n }\n return 0;\n}\nfunction measureLabelSize(ctx, font, label) {\n label = isArray(label) ? label : [label];\n return {\n w: _longestText(ctx, font.string, label),\n h: label.length * font.lineHeight\n };\n}\nfunction determineLimits(angle, pos, size, min, max) {\n if (angle === min || angle === max) {\n return {\n start: pos - (size / 2),\n end: pos + (size / 2)\n };\n } else if (angle < min || angle > max) {\n return {\n start: pos - size,\n end: pos\n };\n }\n return {\n start: pos,\n end: pos + size\n };\n}\nfunction fitWithPointLabels(scale) {\n const orig = {\n l: scale.left + scale._padding.left,\n r: scale.right - scale._padding.right,\n t: scale.top + scale._padding.top,\n b: scale.bottom - scale._padding.bottom\n };\n const limits = Object.assign({}, orig);\n const labelSizes = [];\n const padding = [];\n const valueCount = scale._pointLabels.length;\n const pointLabelOpts = scale.options.pointLabels;\n const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;\n for (let i = 0; i < valueCount; i++) {\n const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i));\n padding[i] = opts.padding;\n const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle);\n const plFont = toFont(opts.font);\n const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]);\n labelSizes[i] = textSize;\n const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle);\n const angle = Math.round(toDegrees(angleRadians));\n const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);\n const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);\n updateLimits(limits, orig, angleRadians, hLimits, vLimits);\n }\n scale.setCenterPoint(\n orig.l - limits.l,\n limits.r - orig.r,\n orig.t - limits.t,\n limits.b - orig.b\n );\n scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);\n}\nfunction updateLimits(limits, orig, angle, hLimits, vLimits) {\n const sin = Math.abs(Math.sin(angle));\n const cos = Math.abs(Math.cos(angle));\n let x = 0;\n let y = 0;\n if (hLimits.start < orig.l) {\n x = (orig.l - hLimits.start) / sin;\n limits.l = Math.min(limits.l, orig.l - x);\n } else if (hLimits.end > orig.r) {\n x = (hLimits.end - orig.r) / sin;\n limits.r = Math.max(limits.r, orig.r + x);\n }\n if (vLimits.start < orig.t) {\n y = (orig.t - vLimits.start) / cos;\n limits.t = Math.min(limits.t, orig.t - y);\n } else if (vLimits.end > orig.b) {\n y = (vLimits.end - orig.b) / cos;\n limits.b = Math.max(limits.b, orig.b + y);\n }\n}\nfunction buildPointLabelItems(scale, labelSizes, padding) {\n const items = [];\n const valueCount = scale._pointLabels.length;\n const opts = scale.options;\n const extra = getTickBackdropHeight(opts) / 2;\n const outerDistance = scale.drawingArea;\n const additionalAngle = opts.pointLabels.centerPointLabels ? PI / valueCount : 0;\n for (let i = 0; i < valueCount; i++) {\n const pointLabelPosition = scale.getPointPosition(i, outerDistance + extra + padding[i], additionalAngle);\n const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));\n const size = labelSizes[i];\n const y = yForAngle(pointLabelPosition.y, size.h, angle);\n const textAlign = getTextAlignForAngle(angle);\n const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign);\n items.push({\n x: pointLabelPosition.x,\n y,\n textAlign,\n left,\n top: y,\n right: left + size.w,\n bottom: y + size.h\n });\n }\n return items;\n}\nfunction getTextAlignForAngle(angle) {\n if (angle === 0 || angle === 180) {\n return 'center';\n } else if (angle < 180) {\n return 'left';\n }\n return 'right';\n}\nfunction leftForTextAlign(x, w, align) {\n if (align === 'right') {\n x -= w;\n } else if (align === 'center') {\n x -= (w / 2);\n }\n return x;\n}\nfunction yForAngle(y, h, angle) {\n if (angle === 90 || angle === 270) {\n y -= (h / 2);\n } else if (angle > 270 || angle < 90) {\n y -= h;\n }\n return y;\n}\nfunction drawPointLabels(scale, labelCount) {\n const {ctx, options: {pointLabels}} = scale;\n for (let i = labelCount - 1; i >= 0; i--) {\n const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i));\n const plFont = toFont(optsAtIndex.font);\n const {x, y, textAlign, left, top, right, bottom} = scale._pointLabelItems[i];\n const {backdropColor} = optsAtIndex;\n if (!isNullOrUndef(backdropColor)) {\n const borderRadius = toTRBLCorners(optsAtIndex.borderRadius);\n const padding = toPadding(optsAtIndex.backdropPadding);\n ctx.fillStyle = backdropColor;\n const backdropLeft = left - padding.left;\n const backdropTop = top - padding.top;\n const backdropWidth = right - left + padding.width;\n const backdropHeight = bottom - top + padding.height;\n if (Object.values(borderRadius).some(v => v !== 0)) {\n ctx.beginPath();\n addRoundedRectPath(ctx, {\n x: backdropLeft,\n y: backdropTop,\n w: backdropWidth,\n h: backdropHeight,\n radius: borderRadius,\n });\n ctx.fill();\n } else {\n ctx.fillRect(backdropLeft, backdropTop, backdropWidth, backdropHeight);\n }\n }\n renderText(\n ctx,\n scale._pointLabels[i],\n x,\n y + (plFont.lineHeight / 2),\n plFont,\n {\n color: optsAtIndex.color,\n textAlign: textAlign,\n textBaseline: 'middle'\n }\n );\n }\n}\nfunction pathRadiusLine(scale, radius, circular, labelCount) {\n const {ctx} = scale;\n if (circular) {\n ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU);\n } else {\n let pointPosition = scale.getPointPosition(0, radius);\n ctx.moveTo(pointPosition.x, pointPosition.y);\n for (let i = 1; i < labelCount; i++) {\n pointPosition = scale.getPointPosition(i, radius);\n ctx.lineTo(pointPosition.x, pointPosition.y);\n }\n }\n}\nfunction drawRadiusLine(scale, gridLineOpts, radius, labelCount) {\n const ctx = scale.ctx;\n const circular = gridLineOpts.circular;\n const {color, lineWidth} = gridLineOpts;\n if ((!circular && !labelCount) || !color || !lineWidth || radius < 0) {\n return;\n }\n ctx.save();\n ctx.strokeStyle = color;\n ctx.lineWidth = lineWidth;\n ctx.setLineDash(gridLineOpts.borderDash);\n ctx.lineDashOffset = gridLineOpts.borderDashOffset;\n ctx.beginPath();\n pathRadiusLine(scale, radius, circular, labelCount);\n ctx.closePath();\n ctx.stroke();\n ctx.restore();\n}\nfunction createPointLabelContext(parent, index, label) {\n return createContext(parent, {\n label,\n index,\n type: 'pointLabel'\n });\n}\nclass RadialLinearScale extends LinearScaleBase {\n constructor(cfg) {\n super(cfg);\n this.xCenter = undefined;\n this.yCenter = undefined;\n this.drawingArea = undefined;\n this._pointLabels = [];\n this._pointLabelItems = [];\n }\n setDimensions() {\n const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);\n const w = this.width = this.maxWidth - padding.width;\n const h = this.height = this.maxHeight - padding.height;\n this.xCenter = Math.floor(this.left + w / 2 + padding.left);\n this.yCenter = Math.floor(this.top + h / 2 + padding.top);\n this.drawingArea = Math.floor(Math.min(w, h) / 2);\n }\n determineDataLimits() {\n const {min, max} = this.getMinMax(false);\n this.min = isNumberFinite(min) && !isNaN(min) ? min : 0;\n this.max = isNumberFinite(max) && !isNaN(max) ? max : 0;\n this.handleTickRangeOptions();\n }\n computeTickLimit() {\n return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));\n }\n generateTickLabels(ticks) {\n LinearScaleBase.prototype.generateTickLabels.call(this, ticks);\n this._pointLabels = this.getLabels()\n .map((value, index) => {\n const label = callback(this.options.pointLabels.callback, [value, index], this);\n return label || label === 0 ? label : '';\n })\n .filter((v, i) => this.chart.getDataVisibility(i));\n }\n fit() {\n const opts = this.options;\n if (opts.display && opts.pointLabels.display) {\n fitWithPointLabels(this);\n } else {\n this.setCenterPoint(0, 0, 0, 0);\n }\n }\n setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {\n this.xCenter += Math.floor((leftMovement - rightMovement) / 2);\n this.yCenter += Math.floor((topMovement - bottomMovement) / 2);\n this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));\n }\n getIndexAngle(index) {\n const angleMultiplier = TAU / (this._pointLabels.length || 1);\n const startAngle = this.options.startAngle || 0;\n return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));\n }\n getDistanceFromCenterForValue(value) {\n if (isNullOrUndef(value)) {\n return NaN;\n }\n const scalingFactor = this.drawingArea / (this.max - this.min);\n if (this.options.reverse) {\n return (this.max - value) * scalingFactor;\n }\n return (value - this.min) * scalingFactor;\n }\n getValueForDistanceFromCenter(distance) {\n if (isNullOrUndef(distance)) {\n return NaN;\n }\n const scaledDistance = distance / (this.drawingArea / (this.max - this.min));\n return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance;\n }\n getPointLabelContext(index) {\n const pointLabels = this._pointLabels || [];\n if (index >= 0 && index < pointLabels.length) {\n const pointLabel = pointLabels[index];\n return createPointLabelContext(this.getContext(), index, pointLabel);\n }\n }\n getPointPosition(index, distanceFromCenter, additionalAngle = 0) {\n const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;\n return {\n x: Math.cos(angle) * distanceFromCenter + this.xCenter,\n y: Math.sin(angle) * distanceFromCenter + this.yCenter,\n angle\n };\n }\n getPointPositionForValue(index, value) {\n return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));\n }\n getBasePosition(index) {\n return this.getPointPositionForValue(index || 0, this.getBaseValue());\n }\n getPointLabelPosition(index) {\n const {left, top, right, bottom} = this._pointLabelItems[index];\n return {\n left,\n top,\n right,\n bottom,\n };\n }\n drawBackground() {\n const {backgroundColor, grid: {circular}} = this.options;\n if (backgroundColor) {\n const ctx = this.ctx;\n ctx.save();\n ctx.beginPath();\n pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);\n ctx.closePath();\n ctx.fillStyle = backgroundColor;\n ctx.fill();\n ctx.restore();\n }\n }\n drawGrid() {\n const ctx = this.ctx;\n const opts = this.options;\n const {angleLines, grid} = opts;\n const labelCount = this._pointLabels.length;\n let i, offset, position;\n if (opts.pointLabels.display) {\n drawPointLabels(this, labelCount);\n }\n if (grid.display) {\n this.ticks.forEach((tick, index) => {\n if (index !== 0) {\n offset = this.getDistanceFromCenterForValue(tick.value);\n const optsAtIndex = grid.setContext(this.getContext(index - 1));\n drawRadiusLine(this, optsAtIndex, offset, labelCount);\n }\n });\n }\n if (angleLines.display) {\n ctx.save();\n for (i = labelCount - 1; i >= 0; i--) {\n const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i));\n const {color, lineWidth} = optsAtIndex;\n if (!lineWidth || !color) {\n continue;\n }\n ctx.lineWidth = lineWidth;\n ctx.strokeStyle = color;\n ctx.setLineDash(optsAtIndex.borderDash);\n ctx.lineDashOffset = optsAtIndex.borderDashOffset;\n offset = this.getDistanceFromCenterForValue(opts.ticks.reverse ? this.min : this.max);\n position = this.getPointPosition(i, offset);\n ctx.beginPath();\n ctx.moveTo(this.xCenter, this.yCenter);\n ctx.lineTo(position.x, position.y);\n ctx.stroke();\n }\n ctx.restore();\n }\n }\n drawBorder() {}\n drawLabels() {\n const ctx = this.ctx;\n const opts = this.options;\n const tickOpts = opts.ticks;\n if (!tickOpts.display) {\n return;\n }\n const startAngle = this.getIndexAngle(0);\n let offset, width;\n ctx.save();\n ctx.translate(this.xCenter, this.yCenter);\n ctx.rotate(startAngle);\n ctx.textAlign = 'center';\n ctx.textBaseline = 'middle';\n this.ticks.forEach((tick, index) => {\n if (index === 0 && !opts.reverse) {\n return;\n }\n const optsAtIndex = tickOpts.setContext(this.getContext(index));\n const tickFont = toFont(optsAtIndex.font);\n offset = this.getDistanceFromCenterForValue(this.ticks[index].value);\n if (optsAtIndex.showLabelBackdrop) {\n ctx.font = tickFont.string;\n width = ctx.measureText(tick.label).width;\n ctx.fillStyle = optsAtIndex.backdropColor;\n const padding = toPadding(optsAtIndex.backdropPadding);\n ctx.fillRect(\n -width / 2 - padding.left,\n -offset - tickFont.size / 2 - padding.top,\n width + padding.width,\n tickFont.size + padding.height\n );\n }\n renderText(ctx, tick.label, 0, -offset, tickFont, {\n color: optsAtIndex.color,\n });\n });\n ctx.restore();\n }\n drawTitle() {}\n}\nRadialLinearScale.id = 'radialLinear';\nRadialLinearScale.defaults = {\n display: true,\n animate: true,\n position: 'chartArea',\n angleLines: {\n display: true,\n lineWidth: 1,\n borderDash: [],\n borderDashOffset: 0.0\n },\n grid: {\n circular: false\n },\n startAngle: 0,\n ticks: {\n showLabelBackdrop: true,\n callback: Ticks.formatters.numeric\n },\n pointLabels: {\n backdropColor: undefined,\n backdropPadding: 2,\n display: true,\n font: {\n size: 10\n },\n callback(label) {\n return label;\n },\n padding: 5,\n centerPointLabels: false\n }\n};\nRadialLinearScale.defaultRoutes = {\n 'angleLines.color': 'borderColor',\n 'pointLabels.color': 'color',\n 'ticks.color': 'color'\n};\nRadialLinearScale.descriptors = {\n angleLines: {\n _fallback: 'grid'\n }\n};\n\nconst INTERVALS = {\n millisecond: {common: true, size: 1, steps: 1000},\n second: {common: true, size: 1000, steps: 60},\n minute: {common: true, size: 60000, steps: 60},\n hour: {common: true, size: 3600000, steps: 24},\n day: {common: true, size: 86400000, steps: 30},\n week: {common: false, size: 604800000, steps: 4},\n month: {common: true, size: 2.628e9, steps: 12},\n quarter: {common: false, size: 7.884e9, steps: 4},\n year: {common: true, size: 3.154e10}\n};\nconst UNITS = (Object.keys(INTERVALS));\nfunction sorter(a, b) {\n return a - b;\n}\nfunction parse(scale, input) {\n if (isNullOrUndef(input)) {\n return null;\n }\n const adapter = scale._adapter;\n const {parser, round, isoWeekday} = scale._parseOpts;\n let value = input;\n if (typeof parser === 'function') {\n value = parser(value);\n }\n if (!isNumberFinite(value)) {\n value = typeof parser === 'string'\n ? adapter.parse(value, parser)\n : adapter.parse(value);\n }\n if (value === null) {\n return null;\n }\n if (round) {\n value = round === 'week' && (isNumber(isoWeekday) || isoWeekday === true)\n ? adapter.startOf(value, 'isoWeek', isoWeekday)\n : adapter.startOf(value, round);\n }\n return +value;\n}\nfunction determineUnitForAutoTicks(minUnit, min, max, capacity) {\n const ilen = UNITS.length;\n for (let i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) {\n const interval = INTERVALS[UNITS[i]];\n const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER;\n if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) {\n return UNITS[i];\n }\n }\n return UNITS[ilen - 1];\n}\nfunction determineUnitForFormatting(scale, numTicks, minUnit, min, max) {\n for (let i = UNITS.length - 1; i >= UNITS.indexOf(minUnit); i--) {\n const unit = UNITS[i];\n if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) {\n return unit;\n }\n }\n return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0];\n}\nfunction determineMajorUnit(unit) {\n for (let i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) {\n if (INTERVALS[UNITS[i]].common) {\n return UNITS[i];\n }\n }\n}\nfunction addTick(ticks, time, timestamps) {\n if (!timestamps) {\n ticks[time] = true;\n } else if (timestamps.length) {\n const {lo, hi} = _lookup(timestamps, time);\n const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi];\n ticks[timestamp] = true;\n }\n}\nfunction setMajorTicks(scale, ticks, map, majorUnit) {\n const adapter = scale._adapter;\n const first = +adapter.startOf(ticks[0].value, majorUnit);\n const last = ticks[ticks.length - 1].value;\n let major, index;\n for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) {\n index = map[major];\n if (index >= 0) {\n ticks[index].major = true;\n }\n }\n return ticks;\n}\nfunction ticksFromTimestamps(scale, values, majorUnit) {\n const ticks = [];\n const map = {};\n const ilen = values.length;\n let i, value;\n for (i = 0; i < ilen; ++i) {\n value = values[i];\n map[value] = i;\n ticks.push({\n value,\n major: false\n });\n }\n return (ilen === 0 || !majorUnit) ? ticks : setMajorTicks(scale, ticks, map, majorUnit);\n}\nclass TimeScale extends Scale {\n constructor(props) {\n super(props);\n this._cache = {\n data: [],\n labels: [],\n all: []\n };\n this._unit = 'day';\n this._majorUnit = undefined;\n this._offsets = {};\n this._normalized = false;\n this._parseOpts = undefined;\n }\n init(scaleOpts, opts) {\n const time = scaleOpts.time || (scaleOpts.time = {});\n const adapter = this._adapter = new adapters._date(scaleOpts.adapters.date);\n mergeIf(time.displayFormats, adapter.formats());\n this._parseOpts = {\n parser: time.parser,\n round: time.round,\n isoWeekday: time.isoWeekday\n };\n super.init(scaleOpts);\n this._normalized = opts.normalized;\n }\n parse(raw, index) {\n if (raw === undefined) {\n return null;\n }\n return parse(this, raw);\n }\n beforeLayout() {\n super.beforeLayout();\n this._cache = {\n data: [],\n labels: [],\n all: []\n };\n }\n determineDataLimits() {\n const options = this.options;\n const adapter = this._adapter;\n const unit = options.time.unit || 'day';\n let {min, max, minDefined, maxDefined} = this.getUserBounds();\n function _applyBounds(bounds) {\n if (!minDefined && !isNaN(bounds.min)) {\n min = Math.min(min, bounds.min);\n }\n if (!maxDefined && !isNaN(bounds.max)) {\n max = Math.max(max, bounds.max);\n }\n }\n if (!minDefined || !maxDefined) {\n _applyBounds(this._getLabelBounds());\n if (options.bounds !== 'ticks' || options.ticks.source !== 'labels') {\n _applyBounds(this.getMinMax(false));\n }\n }\n min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit);\n max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1;\n this.min = Math.min(min, max - 1);\n this.max = Math.max(min + 1, max);\n }\n _getLabelBounds() {\n const arr = this.getLabelTimestamps();\n let min = Number.POSITIVE_INFINITY;\n let max = Number.NEGATIVE_INFINITY;\n if (arr.length) {\n min = arr[0];\n max = arr[arr.length - 1];\n }\n return {min, max};\n }\n buildTicks() {\n const options = this.options;\n const timeOpts = options.time;\n const tickOpts = options.ticks;\n const timestamps = tickOpts.source === 'labels' ? this.getLabelTimestamps() : this._generate();\n if (options.bounds === 'ticks' && timestamps.length) {\n this.min = this._userMin || timestamps[0];\n this.max = this._userMax || timestamps[timestamps.length - 1];\n }\n const min = this.min;\n const max = this.max;\n const ticks = _filterBetween(timestamps, min, max);\n this._unit = timeOpts.unit || (tickOpts.autoSkip\n ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min))\n : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max));\n this._majorUnit = !tickOpts.major.enabled || this._unit === 'year' ? undefined\n : determineMajorUnit(this._unit);\n this.initOffsets(timestamps);\n if (options.reverse) {\n ticks.reverse();\n }\n return ticksFromTimestamps(this, ticks, this._majorUnit);\n }\n afterAutoSkip() {\n if (this.options.offsetAfterAutoskip) {\n this.initOffsets(this.ticks.map(tick => +tick.value));\n }\n }\n initOffsets(timestamps) {\n let start = 0;\n let end = 0;\n let first, last;\n if (this.options.offset && timestamps.length) {\n first = this.getDecimalForValue(timestamps[0]);\n if (timestamps.length === 1) {\n start = 1 - first;\n } else {\n start = (this.getDecimalForValue(timestamps[1]) - first) / 2;\n }\n last = this.getDecimalForValue(timestamps[timestamps.length - 1]);\n if (timestamps.length === 1) {\n end = last;\n } else {\n end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2;\n }\n }\n const limit = timestamps.length < 3 ? 0.5 : 0.25;\n start = _limitValue(start, 0, limit);\n end = _limitValue(end, 0, limit);\n this._offsets = {start, end, factor: 1 / (start + 1 + end)};\n }\n _generate() {\n const adapter = this._adapter;\n const min = this.min;\n const max = this.max;\n const options = this.options;\n const timeOpts = options.time;\n const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min));\n const stepSize = valueOrDefault(timeOpts.stepSize, 1);\n const weekday = minor === 'week' ? timeOpts.isoWeekday : false;\n const hasWeekday = isNumber(weekday) || weekday === true;\n const ticks = {};\n let first = min;\n let time, count;\n if (hasWeekday) {\n first = +adapter.startOf(first, 'isoWeek', weekday);\n }\n first = +adapter.startOf(first, hasWeekday ? 'day' : minor);\n if (adapter.diff(max, min, minor) > 100000 * stepSize) {\n throw new Error(min + ' and ' + max + ' are too far apart with stepSize of ' + stepSize + ' ' + minor);\n }\n const timestamps = options.ticks.source === 'data' && this.getDataTimestamps();\n for (time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++) {\n addTick(ticks, time, timestamps);\n }\n if (time === max || options.bounds === 'ticks' || count === 1) {\n addTick(ticks, time, timestamps);\n }\n return Object.keys(ticks).sort((a, b) => a - b).map(x => +x);\n }\n getLabelForValue(value) {\n const adapter = this._adapter;\n const timeOpts = this.options.time;\n if (timeOpts.tooltipFormat) {\n return adapter.format(value, timeOpts.tooltipFormat);\n }\n return adapter.format(value, timeOpts.displayFormats.datetime);\n }\n _tickFormatFunction(time, index, ticks, format) {\n const options = this.options;\n const formats = options.time.displayFormats;\n const unit = this._unit;\n const majorUnit = this._majorUnit;\n const minorFormat = unit && formats[unit];\n const majorFormat = majorUnit && formats[majorUnit];\n const tick = ticks[index];\n const major = majorUnit && majorFormat && tick && tick.major;\n const label = this._adapter.format(time, format || (major ? majorFormat : minorFormat));\n const formatter = options.ticks.callback;\n return formatter ? callback(formatter, [label, index, ticks], this) : label;\n }\n generateTickLabels(ticks) {\n let i, ilen, tick;\n for (i = 0, ilen = ticks.length; i < ilen; ++i) {\n tick = ticks[i];\n tick.label = this._tickFormatFunction(tick.value, i, ticks);\n }\n }\n getDecimalForValue(value) {\n return value === null ? NaN : (value - this.min) / (this.max - this.min);\n }\n getPixelForValue(value) {\n const offsets = this._offsets;\n const pos = this.getDecimalForValue(value);\n return this.getPixelForDecimal((offsets.start + pos) * offsets.factor);\n }\n getValueForPixel(pixel) {\n const offsets = this._offsets;\n const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;\n return this.min + pos * (this.max - this.min);\n }\n _getLabelSize(label) {\n const ticksOpts = this.options.ticks;\n const tickLabelWidth = this.ctx.measureText(label).width;\n const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation);\n const cosRotation = Math.cos(angle);\n const sinRotation = Math.sin(angle);\n const tickFontSize = this._resolveTickFontOptions(0).size;\n return {\n w: (tickLabelWidth * cosRotation) + (tickFontSize * sinRotation),\n h: (tickLabelWidth * sinRotation) + (tickFontSize * cosRotation)\n };\n }\n _getLabelCapacity(exampleTime) {\n const timeOpts = this.options.time;\n const displayFormats = timeOpts.displayFormats;\n const format = displayFormats[timeOpts.unit] || displayFormats.millisecond;\n const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [exampleTime], this._majorUnit), format);\n const size = this._getLabelSize(exampleLabel);\n const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1;\n return capacity > 0 ? capacity : 1;\n }\n getDataTimestamps() {\n let timestamps = this._cache.data || [];\n let i, ilen;\n if (timestamps.length) {\n return timestamps;\n }\n const metas = this.getMatchingVisibleMetas();\n if (this._normalized && metas.length) {\n return (this._cache.data = metas[0].controller.getAllParsedValues(this));\n }\n for (i = 0, ilen = metas.length; i < ilen; ++i) {\n timestamps = timestamps.concat(metas[i].controller.getAllParsedValues(this));\n }\n return (this._cache.data = this.normalize(timestamps));\n }\n getLabelTimestamps() {\n const timestamps = this._cache.labels || [];\n let i, ilen;\n if (timestamps.length) {\n return timestamps;\n }\n const labels = this.getLabels();\n for (i = 0, ilen = labels.length; i < ilen; ++i) {\n timestamps.push(parse(this, labels[i]));\n }\n return (this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps));\n }\n normalize(values) {\n return _arrayUnique(values.sort(sorter));\n }\n}\nTimeScale.id = 'time';\nTimeScale.defaults = {\n bounds: 'data',\n adapters: {},\n time: {\n parser: false,\n unit: false,\n round: false,\n isoWeekday: false,\n minUnit: 'millisecond',\n displayFormats: {}\n },\n ticks: {\n source: 'auto',\n major: {\n enabled: false\n }\n }\n};\n\nfunction interpolate(table, val, reverse) {\n let lo = 0;\n let hi = table.length - 1;\n let prevSource, nextSource, prevTarget, nextTarget;\n if (reverse) {\n if (val >= table[lo].pos && val <= table[hi].pos) {\n ({lo, hi} = _lookupByKey(table, 'pos', val));\n }\n ({pos: prevSource, time: prevTarget} = table[lo]);\n ({pos: nextSource, time: nextTarget} = table[hi]);\n } else {\n if (val >= table[lo].time && val <= table[hi].time) {\n ({lo, hi} = _lookupByKey(table, 'time', val));\n }\n ({time: prevSource, pos: prevTarget} = table[lo]);\n ({time: nextSource, pos: nextTarget} = table[hi]);\n }\n const span = nextSource - prevSource;\n return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget;\n}\nclass TimeSeriesScale extends TimeScale {\n constructor(props) {\n super(props);\n this._table = [];\n this._minPos = undefined;\n this._tableRange = undefined;\n }\n initOffsets() {\n const timestamps = this._getTimestampsForTable();\n const table = this._table = this.buildLookupTable(timestamps);\n this._minPos = interpolate(table, this.min);\n this._tableRange = interpolate(table, this.max) - this._minPos;\n super.initOffsets(timestamps);\n }\n buildLookupTable(timestamps) {\n const {min, max} = this;\n const items = [];\n const table = [];\n let i, ilen, prev, curr, next;\n for (i = 0, ilen = timestamps.length; i < ilen; ++i) {\n curr = timestamps[i];\n if (curr >= min && curr <= max) {\n items.push(curr);\n }\n }\n if (items.length < 2) {\n return [\n {time: min, pos: 0},\n {time: max, pos: 1}\n ];\n }\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n next = items[i + 1];\n prev = items[i - 1];\n curr = items[i];\n if (Math.round((next + prev) / 2) !== curr) {\n table.push({time: curr, pos: i / (ilen - 1)});\n }\n }\n return table;\n }\n _getTimestampsForTable() {\n let timestamps = this._cache.all || [];\n if (timestamps.length) {\n return timestamps;\n }\n const data = this.getDataTimestamps();\n const label = this.getLabelTimestamps();\n if (data.length && label.length) {\n timestamps = this.normalize(data.concat(label));\n } else {\n timestamps = data.length ? data : label;\n }\n timestamps = this._cache.all = timestamps;\n return timestamps;\n }\n getDecimalForValue(value) {\n return (interpolate(this._table, value) - this._minPos) / this._tableRange;\n }\n getValueForPixel(pixel) {\n const offsets = this._offsets;\n const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;\n return interpolate(this._table, decimal * this._tableRange + this._minPos, true);\n }\n}\nTimeSeriesScale.id = 'timeseries';\nTimeSeriesScale.defaults = TimeScale.defaults;\n\nvar scales = /*#__PURE__*/Object.freeze({\n__proto__: null,\nCategoryScale: CategoryScale,\nLinearScale: LinearScale,\nLogarithmicScale: LogarithmicScale,\nRadialLinearScale: RadialLinearScale,\nTimeScale: TimeScale,\nTimeSeriesScale: TimeSeriesScale\n});\n\nconst registerables = [\n controllers,\n elements,\n plugins,\n scales,\n];\n\nexport { Animation, Animations, ArcElement, BarController, BarElement, BasePlatform, BasicPlatform, BubbleController, CategoryScale, Chart, DatasetController, plugin_decimation as Decimation, DomPlatform, DoughnutController, Element, index as Filler, Interaction, plugin_legend as Legend, LineController, LineElement, LinearScale, LogarithmicScale, PieController, PointElement, PolarAreaController, RadarController, RadialLinearScale, Scale, ScatterController, plugin_subtitle as SubTitle, Ticks, TimeScale, TimeSeriesScale, plugin_title as Title, plugin_tooltip as Tooltip, adapters as _adapters, _detectPlatform, animator, controllers, elements, layouts, plugins, registerables, registry, scales };\n","import {Chart, registerables} from '../dist/chart.esm.js';\n\nChart.register(...registerables);\n\nexport default Chart;\n","/*!\n* chartjs-plugin-annotation v1.4.0\n* https://www.chartjs.org/chartjs-plugin-annotation/index\n * (c) 2022 chartjs-plugin-annotation Contributors\n * Released under the MIT License\n */\nimport { Element, defaults, Animations, Chart } from 'chart.js';\nimport { defined, distanceBetweenPoints, callback, isFinite, valueOrDefault, isObject, toRadians, toFont, isArray, addRoundedRectPath, toTRBLCorners, toPadding, PI, drawPoint, RAD_PER_DEG, clipArea, unclipArea } from 'chart.js/helpers';\n\nconst clickHooks = ['click', 'dblclick'];\nconst moveHooks = ['enter', 'leave'];\nconst hooks = clickHooks.concat(moveHooks);\n\nfunction updateListeners(chart, state, options) {\n state.listened = false;\n state.moveListened = false;\n\n hooks.forEach(hook => {\n if (typeof options[hook] === 'function') {\n state.listened = true;\n state.listeners[hook] = options[hook];\n } else if (defined(state.listeners[hook])) {\n delete state.listeners[hook];\n }\n });\n moveHooks.forEach(hook => {\n if (typeof options[hook] === 'function') {\n state.moveListened = true;\n }\n });\n\n if (!state.listened || !state.moveListened) {\n state.annotations.forEach(scope => {\n if (!state.listened) {\n clickHooks.forEach(hook => {\n if (typeof scope[hook] === 'function') {\n state.listened = true;\n }\n });\n }\n if (!state.moveListened) {\n moveHooks.forEach(hook => {\n if (typeof scope[hook] === 'function') {\n state.listened = true;\n state.moveListened = true;\n }\n });\n }\n });\n }\n}\n\nfunction handleEvent(state, event, options) {\n if (state.listened) {\n switch (event.type) {\n case 'mousemove':\n case 'mouseout':\n handleMoveEvents(state, event);\n break;\n case 'click':\n handleClickEvents(state, event, options);\n break;\n }\n }\n}\n\nfunction handleMoveEvents(state, event) {\n if (!state.moveListened) {\n return;\n }\n\n let element;\n\n if (event.type === 'mousemove') {\n element = getNearestItem(state.elements, event);\n }\n\n const previous = state.hovered;\n state.hovered = element;\n\n dispatchMoveEvents(state, {previous, element}, event);\n}\n\nfunction dispatchMoveEvents(state, elements, event) {\n const {previous, element} = elements;\n if (previous && previous !== element) {\n dispatchEvent(previous.options.leave || state.listeners.leave, previous, event);\n }\n if (element && element !== previous) {\n dispatchEvent(element.options.enter || state.listeners.enter, element, event);\n }\n}\n\nfunction handleClickEvents(state, event, options) {\n const listeners = state.listeners;\n const element = getNearestItem(state.elements, event);\n if (element) {\n const elOpts = element.options;\n const dblclick = elOpts.dblclick || listeners.dblclick;\n const click = elOpts.click || listeners.click;\n if (element.clickTimeout) {\n // 2nd click before timeout, so its a double click\n clearTimeout(element.clickTimeout);\n delete element.clickTimeout;\n dispatchEvent(dblclick, element, event);\n } else if (dblclick) {\n // if there is a dblclick handler, wait for dblClickSpeed ms before deciding its a click\n element.clickTimeout = setTimeout(() => {\n delete element.clickTimeout;\n dispatchEvent(click, element, event);\n }, options.dblClickSpeed);\n } else {\n // no double click handler, just call the click handler directly\n dispatchEvent(click, element, event);\n }\n }\n}\n\nfunction dispatchEvent(handler, element, event) {\n callback(handler, [element.$context, event]);\n}\n\nfunction getNearestItem(elements, position) {\n let minDistance = Number.POSITIVE_INFINITY;\n\n return elements\n .filter((element) => element.options.display && element.inRange(position.x, position.y))\n .reduce((nearestItems, element) => {\n const center = element.getCenterPoint();\n const distance = distanceBetweenPoints(position, center);\n\n if (distance < minDistance) {\n nearestItems = [element];\n minDistance = distance;\n } else if (distance === minDistance) {\n // Can have multiple items at the same distance in which case we sort by size\n nearestItems.push(element);\n }\n\n return nearestItems;\n }, [])\n .sort((a, b) => a._index - b._index)\n .slice(0, 1)[0]; // return only the top item\n}\n\nfunction adjustScaleRange(chart, scale, annotations) {\n const range = getScaleLimits(scale, annotations);\n let changed = changeScaleLimit(scale, range, 'min', 'suggestedMin');\n changed = changeScaleLimit(scale, range, 'max', 'suggestedMax') || changed;\n if (changed && typeof scale.handleTickRangeOptions === 'function') {\n scale.handleTickRangeOptions();\n }\n}\n\nfunction verifyScaleOptions(annotations, scales) {\n for (const annotation of annotations) {\n verifyScaleIDs(annotation, scales);\n }\n}\n\nfunction changeScaleLimit(scale, range, limit, suggestedLimit) {\n if (isFinite(range[limit]) && !scaleLimitDefined(scale.options, limit, suggestedLimit)) {\n const changed = scale[limit] !== range[limit];\n scale[limit] = range[limit];\n return changed;\n }\n}\n\nfunction scaleLimitDefined(scaleOptions, limit, suggestedLimit) {\n return defined(scaleOptions[limit]) || defined(scaleOptions[suggestedLimit]);\n}\n\nfunction verifyScaleIDs(annotation, scales) {\n for (const key of ['scaleID', 'xScaleID', 'yScaleID']) {\n if (annotation[key] && !scales[annotation[key]] && verifyProperties(annotation, key)) {\n console.warn(`No scale found with id '${annotation[key]}' for annotation '${annotation.id}'`);\n }\n }\n}\n\nfunction verifyProperties(annotation, key) {\n if (key === 'scaleID') {\n return true;\n }\n const axis = key.charAt(0);\n for (const prop of ['Min', 'Max', 'Value']) {\n if (defined(annotation[axis + prop])) {\n return true;\n }\n }\n return false;\n}\n\nfunction getScaleLimits(scale, annotations) {\n const axis = scale.axis;\n const scaleID = scale.id;\n const scaleIDOption = axis + 'ScaleID';\n const limits = {\n min: valueOrDefault(scale.min, Number.NEGATIVE_INFINITY),\n max: valueOrDefault(scale.max, Number.POSITIVE_INFINITY)\n };\n for (const annotation of annotations) {\n if (annotation.scaleID === scaleID) {\n updateLimits(annotation, scale, ['value', 'endValue'], limits);\n } else if (annotation[scaleIDOption] === scaleID) {\n updateLimits(annotation, scale, [axis + 'Min', axis + 'Max', axis + 'Value'], limits);\n }\n }\n return limits;\n}\n\nfunction updateLimits(annotation, scale, props, limits) {\n for (const prop of props) {\n const raw = annotation[prop];\n if (defined(raw)) {\n const value = scale.parse(raw);\n limits.min = Math.min(limits.min, value);\n limits.max = Math.max(limits.max, value);\n }\n }\n}\n\nconst EPSILON = 0.001;\n\nconst clamp = (x, from, to) => Math.min(to, Math.max(from, x));\n\nfunction clampAll(obj, from, to) {\n for (const key of Object.keys(obj)) {\n obj[key] = clamp(obj[key], from, to);\n }\n return obj;\n}\n\nfunction inPointRange(point, center, radius, borderWidth) {\n if (!point || !center || radius <= 0) {\n return false;\n }\n const hBorderWidth = borderWidth / 2 || 0;\n return (Math.pow(point.x - center.x, 2) + Math.pow(point.y - center.y, 2)) <= Math.pow(radius + hBorderWidth, 2);\n}\n\nfunction inBoxRange(mouseX, mouseY, {x, y, width, height}, borderWidth) {\n const hBorderWidth = borderWidth / 2;\n return mouseX >= x - hBorderWidth - EPSILON &&\n mouseX <= x + width + hBorderWidth + EPSILON &&\n mouseY >= y - hBorderWidth - EPSILON &&\n mouseY <= y + height + hBorderWidth + EPSILON;\n}\n\nfunction getElementCenterPoint(element, useFinalPosition) {\n const {x, y} = element.getProps(['x', 'y'], useFinalPosition);\n return {x, y};\n}\n\nconst isOlderPart = (act, req) => req > act || (act.length > req.length && act.substr(0, req.length) === req);\n\nfunction requireVersion(pkg, min, ver, strict = true) {\n const parts = ver.split('.');\n let i = 0;\n for (const req of min.split('.')) {\n const act = parts[i++];\n if (parseInt(req, 10) < parseInt(act, 10)) {\n break;\n }\n if (isOlderPart(act, req)) {\n if (strict) {\n throw new Error(`${pkg} v${ver} is not supported. v${min} or newer is required.`);\n } else {\n return false;\n }\n }\n }\n return true;\n}\n\nconst isPercentString = (s) => typeof s === 'string' && s.endsWith('%');\nconst toPercent = (s) => clamp(parseFloat(s) / 100, 0, 1);\n\nfunction getRelativePosition(size, positionOption) {\n if (positionOption === 'start') {\n return 0;\n }\n if (positionOption === 'end') {\n return size;\n }\n if (isPercentString(positionOption)) {\n return toPercent(positionOption) * size;\n }\n return size / 2;\n}\n\nfunction getSize(size, value) {\n if (typeof value === 'number') {\n return value;\n } else if (isPercentString(value)) {\n return toPercent(value) * size;\n }\n return size;\n}\n\nfunction calculateTextAlignment(size, options) {\n const {x, width} = size;\n const textAlign = options.textAlign;\n if (textAlign === 'center') {\n return x + width / 2;\n } else if (textAlign === 'end' || textAlign === 'right') {\n return x + width;\n }\n return x;\n}\n\nfunction toPosition(value) {\n if (isObject(value)) {\n return {\n x: valueOrDefault(value.x, 'center'),\n y: valueOrDefault(value.y, 'center'),\n };\n }\n value = valueOrDefault(value, 'center');\n return {\n x: value,\n y: value\n };\n}\n\nfunction isBoundToPoint(options) {\n return options && (defined(options.xValue) || defined(options.yValue));\n}\n\nconst widthCache = new Map();\n\n/**\n * Determine if content is an image or a canvas.\n * @param {*} content\n * @returns boolean|undefined\n * @todo move this function to chart.js helpers\n */\nfunction isImageOrCanvas(content) {\n if (content && typeof content === 'object') {\n const type = content.toString();\n return (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]');\n }\n}\n\n/**\n * Set the translation on the canvas if the rotation must be applied.\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {Element} element - annotation element to use for applying the translation\n * @param {number} rotation - rotation (in degrees) to apply\n */\nfunction translate(ctx, element, rotation) {\n if (rotation) {\n const center = element.getCenterPoint();\n ctx.translate(center.x, center.y);\n ctx.rotate(toRadians(rotation));\n ctx.translate(-center.x, -center.y);\n }\n}\n\n/**\n * Apply border options to the canvas context before drawing a shape\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {Object} options - options with border configuration\n * @returns {boolean} true is the border options have been applied\n */\nfunction setBorderStyle(ctx, options) {\n if (options && options.borderWidth) {\n ctx.lineCap = options.borderCapStyle;\n ctx.setLineDash(options.borderDash);\n ctx.lineDashOffset = options.borderDashOffset;\n ctx.lineJoin = options.borderJoinStyle;\n ctx.lineWidth = options.borderWidth;\n ctx.strokeStyle = options.borderColor;\n return true;\n }\n}\n\n/**\n * Apply shadow options to the canvas context before drawing a shape\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {Object} options - options with shadow configuration\n */\nfunction setShadowStyle(ctx, options) {\n ctx.shadowColor = options.backgroundShadowColor;\n ctx.shadowBlur = options.shadowBlur;\n ctx.shadowOffsetX = options.shadowOffsetX;\n ctx.shadowOffsetY = options.shadowOffsetY;\n}\n\n/**\n * Measure the label size using the label options.\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {Object} options - options to configure the label\n * @returns {{width: number, height: number}} the measured size of the label\n */\nfunction measureLabelSize(ctx, options) {\n const content = options.content;\n if (isImageOrCanvas(content)) {\n return {\n width: getSize(content.width, options.width),\n height: getSize(content.height, options.height)\n };\n }\n const font = toFont(options.font);\n const strokeWidth = options.textStrokeWidth;\n const lines = isArray(content) ? content : [content];\n const mapKey = lines.join() + font.string + strokeWidth + (ctx._measureText ? '-spriting' : '');\n if (!widthCache.has(mapKey)) {\n ctx.save();\n ctx.font = font.string;\n const count = lines.length;\n let width = 0;\n for (let i = 0; i < count; i++) {\n const text = lines[i];\n width = Math.max(width, ctx.measureText(text).width + strokeWidth);\n }\n ctx.restore();\n const height = count * font.lineHeight + strokeWidth;\n widthCache.set(mapKey, {width, height});\n }\n return widthCache.get(mapKey);\n}\n\n/**\n * Draw a box with the size and the styling options.\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {{x: number, y: number, width: number, height: number}} rect - rect to draw\n * @param {Object} options - options to style the box\n * @returns {undefined}\n */\nfunction drawBox(ctx, rect, options) {\n const {x, y, width, height} = rect;\n ctx.save();\n setShadowStyle(ctx, options);\n const stroke = setBorderStyle(ctx, options);\n ctx.fillStyle = options.backgroundColor;\n ctx.beginPath();\n addRoundedRectPath(ctx, {\n x, y, w: width, h: height,\n // TODO: v2 remove support for cornerRadius\n radius: clampAll(toTRBLCorners(valueOrDefault(options.cornerRadius, options.borderRadius)), 0, Math.min(width, height) / 2)\n });\n ctx.closePath();\n ctx.fill();\n if (stroke) {\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n }\n ctx.restore();\n}\n\n/**\n * Draw a label with the size and the styling options.\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {{x: number, y: number, width: number, height: number}} rect - rect to map teh label\n * @param {Object} options - options to style the label\n * @returns {undefined}\n */\nfunction drawLabel(ctx, rect, options) {\n const content = options.content;\n if (isImageOrCanvas(content)) {\n ctx.drawImage(content, rect.x, rect.y, rect.width, rect.height);\n return;\n }\n const labels = isArray(content) ? content : [content];\n const font = toFont(options.font);\n const lh = font.lineHeight;\n const x = calculateTextAlignment(rect, options);\n const y = rect.y + (lh / 2) + options.textStrokeWidth / 2;\n ctx.save();\n ctx.font = font.string;\n ctx.textBaseline = 'middle';\n ctx.textAlign = options.textAlign;\n if (setTextStrokeStyle(ctx, options)) {\n labels.forEach((l, i) => ctx.strokeText(l, x, y + (i * lh)));\n }\n ctx.fillStyle = options.color;\n labels.forEach((l, i) => ctx.fillText(l, x, y + (i * lh)));\n ctx.restore();\n}\n\nfunction setTextStrokeStyle(ctx, options) {\n if (options.textStrokeWidth > 0) {\n // https://stackoverflow.com/questions/13627111/drawing-text-with-an-outer-stroke-with-html5s-canvas\n ctx.lineJoin = 'round';\n ctx.miterLimit = 2;\n ctx.lineWidth = options.textStrokeWidth;\n ctx.strokeStyle = options.textStrokeColor;\n return true;\n }\n}\n\n/**\n * @typedef {import('chart.js').Point} Point\n */\n\n/**\n * @param {{x: number, y: number, width: number, height: number}} rect\n * @returns {Point}\n */\nfunction getRectCenterPoint(rect) {\n const {x, y, width, height} = rect;\n return {\n x: x + width / 2,\n y: y + height / 2\n };\n}\n\n/**\n * Rotate a `point` relative to `center` point by `angle`\n * @param {Point} point - the point to rotate\n * @param {Point} center - center point for rotation\n * @param {number} angle - angle for rotation, in radians\n * @returns {Point} rotated point\n */\nfunction rotated(point, center, angle) {\n const cos = Math.cos(angle);\n const sin = Math.sin(angle);\n const cx = center.x;\n const cy = center.y;\n\n return {\n x: cx + cos * (point.x - cx) - sin * (point.y - cy),\n y: cy + sin * (point.x - cx) + cos * (point.y - cy)\n };\n}\n\n/**\n * @typedef { import(\"chart.js\").Chart } Chart\n * @typedef { import(\"chart.js\").Scale } Scale\n * @typedef { import(\"chart.js\").Point } Point\n * @typedef { import('../../types/options').CoreAnnotationOptions } CoreAnnotationOptions\n * @typedef { import('../../types/options').PointAnnotationOptions } PointAnnotationOptions\n */\n\n/**\n * @param {Scale} scale\n * @param {number|string} value\n * @param {number} fallback\n * @returns {number}\n */\nfunction scaleValue(scale, value, fallback) {\n value = typeof value === 'number' ? value : scale.parse(value);\n return isFinite(value) ? scale.getPixelForValue(value) : fallback;\n}\n\n/**\n * @param {Scale} scale\n * @param {{start: number, end: number}} options\n * @returns {{start: number, end: number}}\n */\nfunction getChartDimensionByScale(scale, options) {\n if (scale) {\n const min = scaleValue(scale, options.min, options.start);\n const max = scaleValue(scale, options.max, options.end);\n return {\n start: Math.min(min, max),\n end: Math.max(min, max)\n };\n }\n return {\n start: options.start,\n end: options.end\n };\n}\n\n/**\n * @param {Chart} chart\n * @param {CoreAnnotationOptions} options\n * @returns {Point}\n */\nfunction getChartPoint(chart, options) {\n const {chartArea, scales} = chart;\n const xScale = scales[options.xScaleID];\n const yScale = scales[options.yScaleID];\n let x = chartArea.width / 2;\n let y = chartArea.height / 2;\n\n if (xScale) {\n x = scaleValue(xScale, options.xValue, x);\n }\n\n if (yScale) {\n y = scaleValue(yScale, options.yValue, y);\n }\n return {x, y};\n}\n\n/**\n * @param {Chart} chart\n * @param {CoreAnnotationOptions} options\n * @returns {{x?:number, y?: number, x2?: number, y2?: number, width?: number, height?: number}}\n */\nfunction getChartRect(chart, options) {\n const xScale = chart.scales[options.xScaleID];\n const yScale = chart.scales[options.yScaleID];\n let {top: y, left: x, bottom: y2, right: x2} = chart.chartArea;\n\n if (!xScale && !yScale) {\n return {};\n }\n\n const xDim = getChartDimensionByScale(xScale, {min: options.xMin, max: options.xMax, start: x, end: x2});\n x = xDim.start;\n x2 = xDim.end;\n const yDim = getChartDimensionByScale(yScale, {min: options.yMin, max: options.yMax, start: y, end: y2});\n y = yDim.start;\n y2 = yDim.end;\n\n return {\n x,\n y,\n x2,\n y2,\n width: x2 - x,\n height: y2 - y\n };\n}\n\n/**\n * @param {Chart} chart\n * @param {PointAnnotationOptions} options\n */\nfunction getChartCircle(chart, options) {\n const point = getChartPoint(chart, options);\n return {\n x: point.x + options.xAdjust,\n y: point.y + options.yAdjust,\n width: options.radius * 2,\n height: options.radius * 2\n };\n}\n\n/**\n * @param {Chart} chart\n * @param {PointAnnotationOptions} options\n * @returns\n */\nfunction resolvePointPosition(chart, options) {\n if (!isBoundToPoint(options)) {\n const box = getChartRect(chart, options);\n const point = getRectCenterPoint(box);\n let radius = options.radius;\n if (!radius || isNaN(radius)) {\n radius = Math.min(box.width, box.height) / 2;\n options.radius = radius;\n }\n return {\n x: point.x + options.xAdjust,\n y: point.y + options.yAdjust,\n width: radius * 2,\n height: radius * 2\n };\n }\n return getChartCircle(chart, options);\n}\n\nclass BoxAnnotation extends Element {\n inRange(mouseX, mouseY, useFinalPosition) {\n const {x, y} = rotated({x: mouseX, y: mouseY}, this.getCenterPoint(useFinalPosition), toRadians(-this.options.rotation));\n return inBoxRange(x, y, this.getProps(['x', 'y', 'width', 'height'], useFinalPosition), this.options.borderWidth);\n }\n\n getCenterPoint(useFinalPosition) {\n return getRectCenterPoint(this.getProps(['x', 'y', 'width', 'height'], useFinalPosition));\n }\n\n draw(ctx) {\n ctx.save();\n translate(ctx, this, this.options.rotation);\n drawBox(ctx, this, this.options);\n ctx.restore();\n }\n\n drawLabel(ctx) {\n const {x, y, width, height, options} = this;\n const {label, borderWidth} = options;\n const halfBorder = borderWidth / 2;\n const position = toPosition(label.position);\n const padding = toPadding(label.padding);\n const labelSize = measureLabelSize(ctx, label);\n const labelRect = {\n x: calculateX(this, labelSize, position, padding),\n y: calculateY(this, labelSize, position, padding),\n width: labelSize.width,\n height: labelSize.height\n };\n\n ctx.save();\n translate(ctx, this, label.rotation);\n ctx.beginPath();\n ctx.rect(x + halfBorder + padding.left, y + halfBorder + padding.top,\n width - borderWidth - padding.width, height - borderWidth - padding.height);\n ctx.clip();\n drawLabel(ctx, labelRect, label);\n ctx.restore();\n }\n\n resolveElementProperties(chart, options) {\n return getChartRect(chart, options);\n }\n}\n\nBoxAnnotation.id = 'boxAnnotation';\n\nBoxAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundShadowColor: 'transparent',\n borderCapStyle: 'butt',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderRadius: 0,\n borderShadowColor: 'transparent',\n borderWidth: 1,\n cornerRadius: undefined, // TODO: v2 remove support for cornerRadius\n display: true,\n label: {\n borderWidth: undefined,\n color: 'black',\n content: null,\n drawTime: undefined,\n enabled: false,\n font: {\n family: undefined,\n lineHeight: undefined,\n size: undefined,\n style: undefined,\n weight: 'bold'\n },\n height: undefined,\n padding: 6,\n position: 'center',\n rotation: undefined,\n textAlign: 'start',\n textStrokeColor: undefined,\n textStrokeWidth: 0,\n xAdjust: 0,\n yAdjust: 0,\n width: undefined\n },\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y'\n};\n\nBoxAnnotation.defaultRoutes = {\n borderColor: 'color',\n backgroundColor: 'color'\n};\n\nBoxAnnotation.descriptors = {\n label: {\n _fallback: true\n }\n};\n\nfunction calculateX(box, labelSize, position, padding) {\n const {x: start, x2: end, width: size, options} = box;\n const {xAdjust: adjust, borderWidth} = options.label;\n return calculatePosition$1({start, end, size}, {\n position: position.x,\n padding: {start: padding.left, end: padding.right},\n adjust, borderWidth,\n size: labelSize.width\n });\n}\n\nfunction calculateY(box, labelSize, position, padding) {\n const {y: start, y2: end, height: size, options} = box;\n const {yAdjust: adjust, borderWidth} = options.label;\n return calculatePosition$1({start, end, size}, {\n position: position.y,\n padding: {start: padding.top, end: padding.bottom},\n adjust, borderWidth,\n size: labelSize.height\n });\n}\n\nfunction calculatePosition$1(boxOpts, labelOpts) {\n const {start, end} = boxOpts;\n const {position, padding: {start: padStart, end: padEnd}, adjust, borderWidth} = labelOpts;\n const availableSize = end - borderWidth - start - padStart - padEnd - labelOpts.size;\n return start + borderWidth / 2 + adjust + padStart + getRelativePosition(availableSize, position);\n}\n\nconst pointInLine = (p1, p2, t) => ({x: p1.x + t * (p2.x - p1.x), y: p1.y + t * (p2.y - p1.y)});\nconst interpolateX = (y, p1, p2) => pointInLine(p1, p2, Math.abs((y - p1.y) / (p2.y - p1.y))).x;\nconst interpolateY = (x, p1, p2) => pointInLine(p1, p2, Math.abs((x - p1.x) / (p2.x - p1.x))).y;\nconst sqr = v => v * v;\nconst defaultEpsilon = 0.001;\n\nfunction isLineInArea({x, y, x2, y2}, {top, right, bottom, left}) {\n return !(\n (x < left && x2 < left) ||\n (x > right && x2 > right) ||\n (y < top && y2 < top) ||\n (y > bottom && y2 > bottom)\n );\n}\n\nfunction limitPointToArea({x, y}, p2, {top, right, bottom, left}) {\n if (x < left) {\n y = interpolateY(left, {x, y}, p2);\n x = left;\n }\n if (x > right) {\n y = interpolateY(right, {x, y}, p2);\n x = right;\n }\n if (y < top) {\n x = interpolateX(top, {x, y}, p2);\n y = top;\n }\n if (y > bottom) {\n x = interpolateX(bottom, {x, y}, p2);\n y = bottom;\n }\n return {x, y};\n}\n\nfunction limitLineToArea(p1, p2, area) {\n const {x, y} = limitPointToArea(p1, p2, area);\n const {x: x2, y: y2} = limitPointToArea(p2, p1, area);\n return {x, y, x2, y2, width: Math.abs(x2 - x), height: Math.abs(y2 - y)};\n}\n\nclass LineAnnotation extends Element {\n\n // TODO: make private in v2\n intersects(x, y, epsilon = defaultEpsilon, useFinalPosition) {\n // Adapted from https://stackoverflow.com/a/6853926/25507\n const {x: x1, y: y1, x2, y2} = this.getProps(['x', 'y', 'x2', 'y2'], useFinalPosition);\n const dx = x2 - x1;\n const dy = y2 - y1;\n const lenSq = sqr(dx) + sqr(dy);\n const t = lenSq === 0 ? -1 : ((x - x1) * dx + (y - y1) * dy) / lenSq;\n let xx, yy;\n if (t < 0) {\n xx = x1;\n yy = y1;\n } else if (t > 1) {\n xx = x2;\n yy = y2;\n } else {\n xx = x1 + t * dx;\n yy = y1 + t * dy;\n }\n return (sqr(x - xx) + sqr(y - yy)) <= epsilon;\n }\n\n /**\n * @todo make private in v2\n * @param {boolean} useFinalPosition - use the element's animation target instead of current position\n * @param {top, right, bottom, left} [chartArea] - optional, area of the chart\n * @returns {boolean} true if the label is visible\n */\n labelIsVisible(useFinalPosition, chartArea) {\n const labelOpts = this.options.label;\n if (!labelOpts || !labelOpts.enabled) {\n return false;\n }\n return !chartArea || isLineInArea(this.getProps(['x', 'y', 'x2', 'y2'], useFinalPosition), chartArea);\n }\n\n // TODO: make private in v2\n isOnLabel(mouseX, mouseY, useFinalPosition) {\n if (!this.labelIsVisible(useFinalPosition)) {\n return false;\n }\n const {labelX, labelY, labelWidth, labelHeight, labelRotation} = this.getProps(['labelX', 'labelY', 'labelWidth', 'labelHeight', 'labelRotation'], useFinalPosition);\n const {x, y} = rotated({x: mouseX, y: mouseY}, {x: labelX, y: labelY}, -labelRotation);\n const hBorderWidth = this.options.label.borderWidth / 2 || 0;\n const w2 = labelWidth / 2 + hBorderWidth;\n const h2 = labelHeight / 2 + hBorderWidth;\n return x >= labelX - w2 - defaultEpsilon && x <= labelX + w2 + defaultEpsilon &&\n y >= labelY - h2 - defaultEpsilon && y <= labelY + h2 + defaultEpsilon;\n }\n\n inRange(mouseX, mouseY, useFinalPosition) {\n const epsilon = sqr(this.options.borderWidth / 2);\n return this.intersects(mouseX, mouseY, epsilon, useFinalPosition) || this.isOnLabel(mouseX, mouseY, useFinalPosition);\n }\n\n getCenterPoint() {\n return {\n x: (this.x2 + this.x) / 2,\n y: (this.y2 + this.y) / 2\n };\n }\n\n draw(ctx) {\n const {x, y, x2, y2, options} = this;\n\n ctx.save();\n if (!setBorderStyle(ctx, options)) {\n // no border width, then line is not drawn\n return ctx.restore();\n }\n setShadowStyle(ctx, options);\n const angle = Math.atan2(y2 - y, x2 - x);\n const length = Math.sqrt(Math.pow(x2 - x, 2) + Math.pow(y2 - y, 2));\n const {startOpts, endOpts, startAdjust, endAdjust} = getArrowHeads(this);\n\n ctx.translate(x, y);\n ctx.rotate(angle);\n ctx.beginPath();\n ctx.moveTo(0 + startAdjust, 0);\n ctx.lineTo(length - endAdjust, 0);\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n drawArrowHead(ctx, 0, startAdjust, startOpts);\n drawArrowHead(ctx, length, -endAdjust, endOpts);\n ctx.restore();\n }\n\n drawLabel(ctx, chartArea) {\n if (!this.labelIsVisible(false, chartArea)) {\n return;\n }\n const {labelX, labelY, labelWidth, labelHeight, labelRotation, labelPadding, labelTextSize, options: {label}} = this;\n\n ctx.save();\n ctx.translate(labelX, labelY);\n ctx.rotate(labelRotation);\n\n const boxRect = {\n x: -(labelWidth / 2),\n y: -(labelHeight / 2),\n width: labelWidth,\n height: labelHeight\n };\n drawBox(ctx, boxRect, label);\n\n const labelTextRect = {\n x: -(labelWidth / 2) + labelPadding.left + label.borderWidth / 2,\n y: -(labelHeight / 2) + labelPadding.top + label.borderWidth / 2,\n width: labelTextSize.width,\n height: labelTextSize.height\n };\n drawLabel(ctx, labelTextRect, label);\n ctx.restore();\n }\n\n resolveElementProperties(chart, options) {\n const scale = chart.scales[options.scaleID];\n let {top: y, left: x, bottom: y2, right: x2} = chart.chartArea;\n let min, max;\n\n if (scale) {\n min = scaleValue(scale, options.value, NaN);\n max = scaleValue(scale, options.endValue, min);\n if (scale.isHorizontal()) {\n x = min;\n x2 = max;\n } else {\n y = min;\n y2 = max;\n }\n } else {\n const xScale = chart.scales[options.xScaleID];\n const yScale = chart.scales[options.yScaleID];\n\n if (xScale) {\n x = scaleValue(xScale, options.xMin, x);\n x2 = scaleValue(xScale, options.xMax, x2);\n }\n\n if (yScale) {\n y = scaleValue(yScale, options.yMin, y);\n y2 = scaleValue(yScale, options.yMax, y2);\n }\n }\n const inside = isLineInArea({x, y, x2, y2}, chart.chartArea);\n const properties = inside\n ? limitLineToArea({x, y}, {x: x2, y: y2}, chart.chartArea)\n : {x, y, x2, y2, width: Math.abs(x2 - x), height: Math.abs(y2 - y)};\n\n const label = options.label;\n if (label && label.content) {\n return loadLabelRect(properties, chart, label);\n }\n return properties;\n }\n}\n\nLineAnnotation.id = 'lineAnnotation';\n\nconst arrowHeadsDefaults = {\n backgroundColor: undefined,\n backgroundShadowColor: undefined,\n borderColor: undefined,\n borderDash: undefined,\n borderDashOffset: undefined,\n borderShadowColor: undefined,\n borderWidth: undefined,\n enabled: undefined,\n fill: undefined,\n length: undefined,\n shadowBlur: undefined,\n shadowOffsetX: undefined,\n shadowOffsetY: undefined,\n width: undefined\n};\n\nLineAnnotation.defaults = {\n adjustScaleRange: true,\n arrowHeads: {\n enabled: false,\n end: Object.assign({}, arrowHeadsDefaults),\n fill: false,\n length: 12,\n start: Object.assign({}, arrowHeadsDefaults),\n width: 6\n },\n borderDash: [],\n borderDashOffset: 0,\n borderShadowColor: 'transparent',\n borderWidth: 2,\n display: true,\n endValue: undefined,\n label: {\n backgroundColor: 'rgba(0,0,0,0.8)',\n backgroundShadowColor: 'transparent',\n borderCapStyle: 'butt',\n borderColor: 'black',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderRadius: 6,\n borderShadowColor: 'transparent',\n borderWidth: 0,\n color: '#fff',\n content: null,\n cornerRadius: undefined, // TODO: v2 remove support for cornerRadius\n drawTime: undefined,\n enabled: false,\n font: {\n family: undefined,\n lineHeight: undefined,\n size: undefined,\n style: undefined,\n weight: 'bold'\n },\n height: undefined,\n padding: 6,\n position: 'center',\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n textAlign: 'center',\n textStrokeColor: undefined,\n textStrokeWidth: 0,\n width: undefined,\n xAdjust: 0,\n xPadding: undefined, // TODO: v2 remove support for xPadding\n yAdjust: 0,\n yPadding: undefined, // TODO: v2 remove support for yPadding\n },\n scaleID: undefined,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n value: undefined,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y'\n};\n\nLineAnnotation.descriptors = {\n arrowHeads: {\n start: {\n _fallback: true\n },\n end: {\n _fallback: true\n },\n _fallback: true\n }\n};\n\nLineAnnotation.defaultRoutes = {\n borderColor: 'color'\n};\n\nfunction loadLabelRect(line, chart, options) {\n // TODO: v2 remove support for xPadding and yPadding\n const {padding: lblPadding, xPadding, yPadding, borderWidth} = options;\n const padding = getPadding(lblPadding, xPadding, yPadding);\n const textSize = measureLabelSize(chart.ctx, options);\n const width = textSize.width + padding.width + borderWidth;\n const height = textSize.height + padding.height + borderWidth;\n const labelRect = calculateLabelPosition(line, options, {width, height, padding}, chart.chartArea);\n line.labelX = labelRect.x;\n line.labelY = labelRect.y;\n line.labelWidth = labelRect.width;\n line.labelHeight = labelRect.height;\n line.labelRotation = labelRect.rotation;\n line.labelPadding = padding;\n line.labelTextSize = textSize;\n return line;\n}\n\nfunction calculateAutoRotation(line) {\n const {x, y, x2, y2} = line;\n const rotation = Math.atan2(y2 - y, x2 - x);\n // Flip the rotation if it goes > PI/2 or < -PI/2, so label stays upright\n return rotation > PI / 2 ? rotation - PI : rotation < PI / -2 ? rotation + PI : rotation;\n}\n\n// TODO: v2 remove support for xPadding and yPadding\nfunction getPadding(padding, xPadding, yPadding) {\n let tempPadding = padding;\n if (xPadding || yPadding) {\n tempPadding = {x: xPadding || 6, y: yPadding || 6};\n }\n return toPadding(tempPadding);\n}\n\nfunction calculateLabelPosition(line, label, sizes, chartArea) {\n const {width, height, padding} = sizes;\n const {xAdjust, yAdjust} = label;\n const p1 = {x: line.x, y: line.y};\n const p2 = {x: line.x2, y: line.y2};\n const rotation = label.rotation === 'auto' ? calculateAutoRotation(line) : toRadians(label.rotation);\n const size = rotatedSize(width, height, rotation);\n const t = calculateT(line, label, {labelSize: size, padding}, chartArea);\n const pt = pointInLine(p1, p2, t);\n const xCoordinateSizes = {size: size.w, min: chartArea.left, max: chartArea.right, padding: padding.left};\n const yCoordinateSizes = {size: size.h, min: chartArea.top, max: chartArea.bottom, padding: padding.top};\n\n return {\n x: adjustLabelCoordinate(pt.x, xCoordinateSizes) + xAdjust,\n y: adjustLabelCoordinate(pt.y, yCoordinateSizes) + yAdjust,\n width,\n height,\n rotation\n };\n}\n\nfunction rotatedSize(width, height, rotation) {\n const cos = Math.cos(rotation);\n const sin = Math.sin(rotation);\n return {\n w: Math.abs(width * cos) + Math.abs(height * sin),\n h: Math.abs(width * sin) + Math.abs(height * cos)\n };\n}\n\nfunction calculateT(line, label, sizes, chartArea) {\n let t;\n const space = spaceAround(line, chartArea);\n if (label.position === 'start') {\n t = calculateTAdjust({w: line.x2 - line.x, h: line.y2 - line.y}, sizes, label, space);\n } else if (label.position === 'end') {\n t = 1 - calculateTAdjust({w: line.x - line.x2, h: line.y - line.y2}, sizes, label, space);\n } else {\n t = getRelativePosition(1, label.position);\n }\n return t;\n}\n\nfunction calculateTAdjust(lineSize, sizes, label, space) {\n const {labelSize, padding} = sizes;\n const lineW = lineSize.w * space.dx;\n const lineH = lineSize.h * space.dy;\n const x = (lineW > 0) && ((labelSize.w / 2 + padding.left - space.x) / lineW);\n const y = (lineH > 0) && ((labelSize.h / 2 + padding.top - space.y) / lineH);\n return clamp(Math.max(x, y), 0, 0.25);\n}\n\nfunction spaceAround(line, chartArea) {\n const {x, x2, y, y2} = line;\n const t = Math.min(y, y2) - chartArea.top;\n const l = Math.min(x, x2) - chartArea.left;\n const b = chartArea.bottom - Math.max(y, y2);\n const r = chartArea.right - Math.max(x, x2);\n return {\n x: Math.min(l, r),\n y: Math.min(t, b),\n dx: l <= r ? 1 : -1,\n dy: t <= b ? 1 : -1\n };\n}\n\nfunction adjustLabelCoordinate(coordinate, labelSizes) {\n const {size, min, max, padding} = labelSizes;\n const halfSize = size / 2;\n if (size > max - min) {\n // if it does not fit, display as much as possible\n return (max + min) / 2;\n }\n if (min >= (coordinate - padding - halfSize)) {\n coordinate = min + padding + halfSize;\n }\n if (max <= (coordinate + padding + halfSize)) {\n coordinate = max - padding - halfSize;\n }\n return coordinate;\n}\n\nfunction getArrowHeads(line) {\n const options = line.options;\n const arrowStartOpts = options.arrowHeads && options.arrowHeads.start;\n const arrowEndOpts = options.arrowHeads && options.arrowHeads.end;\n return {\n startOpts: arrowStartOpts,\n endOpts: arrowEndOpts,\n startAdjust: getLineAdjust(line, arrowStartOpts),\n endAdjust: getLineAdjust(line, arrowEndOpts)\n };\n}\n\nfunction getLineAdjust(line, arrowOpts) {\n if (!arrowOpts || !arrowOpts.enabled) {\n return 0;\n }\n const {length, width} = arrowOpts;\n const adjust = line.options.borderWidth / 2;\n const p1 = {x: length, y: width + adjust};\n const p2 = {x: 0, y: adjust};\n return Math.abs(interpolateX(0, p1, p2));\n}\n\nfunction drawArrowHead(ctx, offset, adjust, arrowOpts) {\n if (!arrowOpts || !arrowOpts.enabled) {\n return;\n }\n const {length, width, fill, backgroundColor, borderColor} = arrowOpts;\n const arrowOffsetX = Math.abs(offset - length) + adjust;\n ctx.beginPath();\n setShadowStyle(ctx, arrowOpts);\n setBorderStyle(ctx, arrowOpts);\n ctx.moveTo(arrowOffsetX, -width);\n ctx.lineTo(offset + adjust, 0);\n ctx.lineTo(arrowOffsetX, width);\n if (fill === true) {\n ctx.fillStyle = backgroundColor || borderColor;\n ctx.closePath();\n ctx.fill();\n ctx.shadowColor = 'transparent';\n } else {\n ctx.shadowColor = arrowOpts.borderShadowColor;\n }\n ctx.stroke();\n}\n\nclass EllipseAnnotation extends Element {\n\n inRange(mouseX, mouseY, useFinalPosition) {\n return pointInEllipse({x: mouseX, y: mouseY}, this.getProps(['width', 'height'], useFinalPosition), this.options.rotation, this.options.borderWidth);\n }\n\n getCenterPoint(useFinalPosition) {\n return getRectCenterPoint(this.getProps(['x', 'y', 'width', 'height'], useFinalPosition));\n }\n\n draw(ctx) {\n const {width, height, options} = this;\n const center = this.getCenterPoint();\n\n ctx.save();\n translate(ctx, this, options.rotation);\n setShadowStyle(ctx, this.options);\n ctx.beginPath();\n ctx.fillStyle = options.backgroundColor;\n const stroke = setBorderStyle(ctx, options);\n ctx.ellipse(center.x, center.y, height / 2, width / 2, PI / 2, 0, 2 * PI);\n ctx.fill();\n if (stroke) {\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n }\n ctx.restore();\n }\n\n resolveElementProperties(chart, options) {\n return getChartRect(chart, options);\n }\n\n}\n\nEllipseAnnotation.id = 'ellipseAnnotation';\n\nEllipseAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundShadowColor: 'transparent',\n borderDash: [],\n borderDashOffset: 0,\n borderShadowColor: 'transparent',\n borderWidth: 1,\n display: true,\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y'\n};\n\nEllipseAnnotation.defaultRoutes = {\n borderColor: 'color',\n backgroundColor: 'color'\n};\n\nfunction pointInEllipse(p, ellipse, rotation, borderWidth) {\n const {width, height} = ellipse;\n const center = ellipse.getCenterPoint(true);\n const xRadius = width / 2;\n const yRadius = height / 2;\n\n if (xRadius <= 0 || yRadius <= 0) {\n return false;\n }\n // https://stackoverflow.com/questions/7946187/point-and-ellipse-rotated-position-test-algorithm\n const angle = toRadians(rotation || 0);\n const hBorderWidth = borderWidth / 2 || 0;\n const cosAngle = Math.cos(angle);\n const sinAngle = Math.sin(angle);\n const a = Math.pow(cosAngle * (p.x - center.x) + sinAngle * (p.y - center.y), 2);\n const b = Math.pow(sinAngle * (p.x - center.x) - cosAngle * (p.y - center.y), 2);\n return (a / Math.pow(xRadius + hBorderWidth, 2)) + (b / Math.pow(yRadius + hBorderWidth, 2)) <= 1.0001;\n}\n\nclass LabelAnnotation extends Element {\n\n inRange(mouseX, mouseY, useFinalPosition) {\n const {x, y} = rotated({x: mouseX, y: mouseY}, this.getCenterPoint(useFinalPosition), toRadians(-this.options.rotation));\n return inBoxRange(x, y, this.getProps(['x', 'y', 'width', 'height'], useFinalPosition), this.options.borderWidth);\n }\n\n getCenterPoint(useFinalPosition) {\n return getRectCenterPoint(this.getProps(['x', 'y', 'width', 'height'], useFinalPosition));\n }\n\n draw(ctx) {\n if (!this.options.content) {\n return;\n }\n const {labelX, labelY, labelWidth, labelHeight, options} = this;\n ctx.save();\n translate(ctx, this, options.rotation);\n drawCallout(ctx, this);\n drawBox(ctx, this, options);\n drawLabel(ctx, {x: labelX, y: labelY, width: labelWidth, height: labelHeight}, options);\n ctx.restore();\n }\n\n // TODO: make private in v2\n resolveElementProperties(chart, options) {\n const point = !isBoundToPoint(options) ? getRectCenterPoint(getChartRect(chart, options)) : getChartPoint(chart, options);\n const padding = toPadding(options.padding);\n const labelSize = measureLabelSize(chart.ctx, options);\n const boxSize = measureRect(point, labelSize, options, padding);\n const hBorderWidth = options.borderWidth / 2;\n const properties = {\n pointX: point.x,\n pointY: point.y,\n ...boxSize,\n labelX: boxSize.x + padding.left + hBorderWidth,\n labelY: boxSize.y + padding.top + hBorderWidth,\n labelWidth: labelSize.width,\n labelHeight: labelSize.height\n };\n properties.calloutPosition = options.callout.enabled && resolveCalloutPosition(properties, options.callout, options.rotation);\n return properties;\n }\n}\n\nLabelAnnotation.id = 'labelAnnotation';\n\nLabelAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundColor: 'transparent',\n backgroundShadowColor: 'transparent',\n borderCapStyle: 'butt',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderRadius: 0,\n borderShadowColor: 'transparent',\n borderWidth: 0,\n callout: {\n borderCapStyle: 'butt',\n borderColor: undefined,\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderWidth: 1,\n enabled: false,\n margin: 5,\n position: 'auto',\n side: 5,\n start: '50%',\n },\n color: 'black',\n content: null,\n display: true,\n font: {\n family: undefined,\n lineHeight: undefined,\n size: undefined,\n style: undefined,\n weight: undefined\n },\n height: undefined,\n padding: 6,\n position: 'center',\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n textAlign: 'center',\n textStrokeColor: undefined,\n textStrokeWidth: 0,\n width: undefined,\n xAdjust: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n xValue: undefined,\n yAdjust: 0,\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y',\n yValue: undefined\n};\n\nLabelAnnotation.defaultRoutes = {\n borderColor: 'color'\n};\n\nfunction measureRect(point, size, options, padding) {\n const width = size.width + padding.width + options.borderWidth;\n const height = size.height + padding.height + options.borderWidth;\n const position = toPosition(options.position);\n\n return {\n x: calculatePosition(point.x, width, options.xAdjust, position.x),\n y: calculatePosition(point.y, height, options.yAdjust, position.y),\n width,\n height\n };\n}\n\nfunction calculatePosition(start, size, adjust = 0, position) {\n return start - getRelativePosition(size, position) + adjust;\n}\n\nfunction drawCallout(ctx, element) {\n const {pointX, pointY, calloutPosition, options} = element;\n if (!calloutPosition || element.inRange(pointX, pointY)) {\n return;\n }\n const callout = options.callout;\n\n ctx.save();\n ctx.beginPath();\n const stroke = setBorderStyle(ctx, callout);\n if (!stroke) {\n return ctx.restore();\n }\n const {separatorStart, separatorEnd} = getCalloutSeparatorCoord(element, calloutPosition);\n const {sideStart, sideEnd} = getCalloutSideCoord(element, calloutPosition, separatorStart);\n if (callout.margin > 0 || options.borderWidth === 0) {\n ctx.moveTo(separatorStart.x, separatorStart.y);\n ctx.lineTo(separatorEnd.x, separatorEnd.y);\n }\n ctx.moveTo(sideStart.x, sideStart.y);\n ctx.lineTo(sideEnd.x, sideEnd.y);\n const rotatedPoint = rotated({x: pointX, y: pointY}, element.getCenterPoint(), toRadians(-options.rotation));\n ctx.lineTo(rotatedPoint.x, rotatedPoint.y);\n ctx.stroke();\n ctx.restore();\n}\n\nfunction getCalloutSeparatorCoord(element, position) {\n const {x, y, width, height} = element;\n const adjust = getCalloutSeparatorAdjust(element, position);\n let separatorStart, separatorEnd;\n if (position === 'left' || position === 'right') {\n separatorStart = {x: x + adjust, y};\n separatorEnd = {x: separatorStart.x, y: separatorStart.y + height};\n } else {\n // position 'top' or 'bottom'\n separatorStart = {x, y: y + adjust};\n separatorEnd = {x: separatorStart.x + width, y: separatorStart.y};\n }\n return {separatorStart, separatorEnd};\n}\n\nfunction getCalloutSeparatorAdjust(element, position) {\n const {width, height, options} = element;\n const adjust = options.callout.margin + options.borderWidth / 2;\n if (position === 'right') {\n return width + adjust;\n } else if (position === 'bottom') {\n return height + adjust;\n }\n return -adjust;\n}\n\nfunction getCalloutSideCoord(element, position, separatorStart) {\n const {y, width, height, options} = element;\n const start = options.callout.start;\n const side = getCalloutSideAdjust(position, options.callout);\n let sideStart, sideEnd;\n if (position === 'left' || position === 'right') {\n sideStart = {x: separatorStart.x, y: y + getSize(height, start)};\n sideEnd = {x: sideStart.x + side, y: sideStart.y};\n } else {\n // position 'top' or 'bottom'\n sideStart = {x: separatorStart.x + getSize(width, start), y: separatorStart.y};\n sideEnd = {x: sideStart.x, y: sideStart.y + side};\n }\n return {sideStart, sideEnd};\n}\n\nfunction getCalloutSideAdjust(position, options) {\n const side = options.side;\n if (position === 'left' || position === 'top') {\n return -side;\n }\n return side;\n}\n\nfunction resolveCalloutPosition(properties, options, rotation) {\n const position = options.position;\n if (position === 'left' || position === 'right' || position === 'top' || position === 'bottom') {\n return position;\n }\n return resolveCalloutAutoPosition(properties, options, rotation);\n}\n\nconst positions = ['left', 'bottom', 'top', 'right'];\n\nfunction resolveCalloutAutoPosition(properties, options, rotation) {\n const {x, y, width, height, pointX, pointY} = properties;\n const center = {x: x + width / 2, y: y + height / 2};\n const start = options.start;\n const xAdjust = getSize(width, start);\n const yAdjust = getSize(height, start);\n const xPoints = [x, x + xAdjust, x + xAdjust, x + width];\n const yPoints = [y + yAdjust, y + height, y, y + yAdjust];\n const result = [];\n for (let index = 0; index < 4; index++) {\n const rotatedPoint = rotated({x: xPoints[index], y: yPoints[index]}, center, toRadians(rotation));\n result.push({\n position: positions[index],\n distance: distanceBetweenPoints(rotatedPoint, {x: pointX, y: pointY})\n });\n }\n return result.sort((a, b) => a.distance - b.distance)[0].position;\n}\n\nclass PointAnnotation extends Element {\n\n inRange(mouseX, mouseY, useFinalPosition) {\n const {width} = this.getProps(['width'], useFinalPosition);\n return inPointRange({x: mouseX, y: mouseY}, this.getCenterPoint(useFinalPosition), width / 2, this.options.borderWidth);\n }\n\n getCenterPoint(useFinalPosition) {\n return getElementCenterPoint(this, useFinalPosition);\n }\n\n draw(ctx) {\n const options = this.options;\n const borderWidth = options.borderWidth;\n if (options.radius < 0.1) {\n return;\n }\n ctx.save();\n ctx.fillStyle = options.backgroundColor;\n setShadowStyle(ctx, options);\n const stroke = setBorderStyle(ctx, options);\n options.borderWidth = 0;\n drawPoint(ctx, options, this.x, this.y);\n if (stroke && !isImageOrCanvas(options.pointStyle)) {\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n }\n ctx.restore();\n options.borderWidth = borderWidth;\n }\n\n resolveElementProperties(chart, options) {\n return resolvePointPosition(chart, options);\n }\n}\n\nPointAnnotation.id = 'pointAnnotation';\n\nPointAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundShadowColor: 'transparent',\n borderDash: [],\n borderDashOffset: 0,\n borderShadowColor: 'transparent',\n borderWidth: 1,\n display: true,\n pointStyle: 'circle',\n radius: 10,\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n xAdjust: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n xValue: undefined,\n yAdjust: 0,\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y',\n yValue: undefined\n};\n\nPointAnnotation.defaultRoutes = {\n borderColor: 'color',\n backgroundColor: 'color'\n};\n\nclass PolygonAnnotation extends Element {\n inRange(mouseX, mouseY, useFinalPosition) {\n return this.options.radius >= 0.1 && this.elements.length > 1 && pointIsInPolygon(this.elements, mouseX, mouseY, useFinalPosition);\n }\n\n getCenterPoint(useFinalPosition) {\n return getElementCenterPoint(this, useFinalPosition);\n }\n\n draw(ctx) {\n const {elements, options} = this;\n ctx.save();\n ctx.beginPath();\n ctx.fillStyle = options.backgroundColor;\n setShadowStyle(ctx, options);\n const stroke = setBorderStyle(ctx, options);\n let first = true;\n for (const el of elements) {\n if (first) {\n ctx.moveTo(el.x, el.y);\n first = false;\n } else {\n ctx.lineTo(el.x, el.y);\n }\n }\n ctx.closePath();\n ctx.fill();\n // If no border, don't draw it\n if (stroke) {\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n }\n ctx.restore();\n }\n\n resolveElementProperties(chart, options) {\n const {x, y, width, height} = resolvePointPosition(chart, options);\n const {sides, radius, rotation, borderWidth} = options;\n const halfBorder = borderWidth / 2;\n const elements = [];\n const angle = (2 * PI) / sides;\n let rad = rotation * RAD_PER_DEG;\n for (let i = 0; i < sides; i++, rad += angle) {\n const sin = Math.sin(rad);\n const cos = Math.cos(rad);\n elements.push({\n type: 'point',\n optionScope: 'point',\n properties: {\n x: x + sin * radius,\n y: y - cos * radius,\n bX: x + sin * (radius + halfBorder),\n bY: y - cos * (radius + halfBorder)\n }\n });\n }\n return {x, y, width, height, elements, initProperties: {x, y}};\n }\n}\n\nPolygonAnnotation.id = 'polygonAnnotation';\n\nPolygonAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundShadowColor: 'transparent',\n borderCapStyle: 'butt',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderShadowColor: 'transparent',\n borderWidth: 1,\n display: true,\n point: {\n radius: 0\n },\n radius: 10,\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n sides: 3,\n xAdjust: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n xValue: undefined,\n yAdjust: 0,\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y',\n yValue: undefined\n};\n\nPolygonAnnotation.defaultRoutes = {\n borderColor: 'color',\n backgroundColor: 'color'\n};\n\n\nfunction pointIsInPolygon(points, x, y, useFinalPosition) {\n let isInside = false;\n let A = points[points.length - 1].getProps(['bX', 'bY'], useFinalPosition);\n for (const point of points) {\n const B = point.getProps(['bX', 'bY'], useFinalPosition);\n if ((B.bY > y) !== (A.bY > y) && x < (A.bX - B.bX) * (y - B.bY) / (A.bY - B.bY) + B.bX) {\n isInside = !isInside;\n }\n A = B;\n }\n return isInside;\n}\n\nconst annotationTypes = {\n box: BoxAnnotation,\n ellipse: EllipseAnnotation,\n label: LabelAnnotation,\n line: LineAnnotation,\n point: PointAnnotation,\n polygon: PolygonAnnotation\n};\n\n/**\n * Register fallback for annotation elements\n * For example lineAnnotation options would be looked through:\n * - the annotation object (options.plugins.annotation.annotations[id])\n * - element options (options.elements.lineAnnotation)\n * - element defaults (defaults.elements.lineAnnotation)\n * - annotation plugin defaults (defaults.plugins.annotation, this is what we are registering here)\n */\nObject.keys(annotationTypes).forEach(key => {\n defaults.describe(`elements.${annotationTypes[key].id}`, {\n _fallback: 'plugins.annotation'\n });\n});\n\nconst directUpdater = {\n update: Object.assign\n};\n\n/**\n * Resolve the annotation type, checking if is supported.\n * @param {string} [type=line] - annotation type\n * @returns {string} resolved annotation type\n */\nfunction resolveType(type = 'line') {\n if (annotationTypes[type]) {\n return type;\n }\n console.warn(`Unknown annotation type: '${type}', defaulting to 'line'`);\n return 'line';\n}\n\n/**\n * Create or update all annotation elements, configured to the plugin.\n * @param {Chart} chart - the chart where the plugin is enabled\n * @param {Object} state - the state of the plugin\n * @param {Object} options - annotation options to use\n * @param {UpdateMode} mode - The update mode\n */\nfunction updateElements(chart, state, options, mode) {\n const animations = resolveAnimations(chart, options.animations, mode);\n\n const annotations = state.annotations;\n const elements = resyncElements(state.elements, annotations);\n\n for (let i = 0; i < annotations.length; i++) {\n const annotationOptions = annotations[i];\n const element = getOrCreateElement(elements, i, annotationOptions.type);\n const resolver = annotationOptions.setContext(getContext(chart, element, annotationOptions));\n const properties = element.resolveElementProperties(chart, resolver);\n\n properties.skip = toSkip(properties);\n\n if ('elements' in properties) {\n updateSubElements(element, properties, resolver, animations);\n // Remove the sub-element definitions from properties, so the actual elements\n // are not overwritten by their definitions\n delete properties.elements;\n }\n\n if (!defined(element.x)) {\n // If the element is newly created, assing the properties directly - to\n // make them readily awailable to any scriptable options. If we do not do this,\n // the properties retruned by `resolveElementProperties` are available only\n // after options resolution.\n Object.assign(element, properties);\n }\n\n properties.options = resolveAnnotationOptions(resolver);\n\n animations.update(element, properties);\n }\n}\n\nfunction toSkip(properties) {\n return isNaN(properties.x) || isNaN(properties.y);\n}\n\nfunction resolveAnimations(chart, animOpts, mode) {\n if (mode === 'reset' || mode === 'none' || mode === 'resize') {\n return directUpdater;\n }\n return new Animations(chart, animOpts);\n}\n\nfunction updateSubElements(mainElement, {elements, initProperties}, resolver, animations) {\n const subElements = mainElement.elements || (mainElement.elements = []);\n subElements.length = elements.length;\n for (let i = 0; i < elements.length; i++) {\n const definition = elements[i];\n const properties = definition.properties;\n const subElement = getOrCreateElement(subElements, i, definition.type, initProperties);\n const subResolver = resolver[definition.optionScope].override(definition);\n properties.options = resolveAnnotationOptions(subResolver);\n animations.update(subElement, properties);\n }\n}\n\nfunction getOrCreateElement(elements, index, type, initProperties) {\n const elementClass = annotationTypes[resolveType(type)];\n let element = elements[index];\n if (!element || !(element instanceof elementClass)) {\n element = elements[index] = new elementClass();\n if (isObject(initProperties)) {\n Object.assign(element, initProperties);\n }\n }\n return element;\n}\n\nfunction resolveAnnotationOptions(resolver) {\n const elementClass = annotationTypes[resolveType(resolver.type)];\n const result = {};\n result.id = resolver.id;\n result.type = resolver.type;\n result.drawTime = resolver.drawTime;\n Object.assign(result,\n resolveObj(resolver, elementClass.defaults),\n resolveObj(resolver, elementClass.defaultRoutes));\n for (const hook of hooks) {\n result[hook] = resolver[hook];\n }\n return result;\n}\n\nfunction resolveObj(resolver, defs) {\n const result = {};\n for (const prop of Object.keys(defs)) {\n const optDefs = defs[prop];\n const value = resolver[prop];\n result[prop] = isObject(optDefs) ? resolveObj(value, optDefs) : value;\n }\n return result;\n}\n\nfunction getContext(chart, element, annotation) {\n return element.$context || (element.$context = Object.assign(Object.create(chart.getContext()), {\n element,\n id: annotation.id,\n type: 'annotation'\n }));\n}\n\nfunction resyncElements(elements, annotations) {\n const count = annotations.length;\n const start = elements.length;\n\n if (start < count) {\n const add = count - start;\n elements.splice(start, 0, ...new Array(add));\n } else if (start > count) {\n elements.splice(count, start - count);\n }\n return elements;\n}\n\nvar name = \"chartjs-plugin-annotation\";\nvar version = \"1.4.0\";\n\nconst chartStates = new Map();\n\nvar annotation = {\n id: 'annotation',\n\n version,\n\n /* TODO: enable in v2\n beforeRegister() {\n requireVersion('chart.js', '3.7', Chart.version);\n },\n */\n\n afterRegister() {\n Chart.register(annotationTypes);\n\n // TODO: Remove this check, warning and workaround in v2\n if (!requireVersion('chart.js', '3.7', Chart.version, false)) {\n console.warn(`${name} has known issues with chart.js versions prior to 3.7, please consider upgrading.`);\n\n // Workaround for https://github.com/chartjs/chartjs-plugin-annotation/issues/572\n Chart.defaults.set('elements.lineAnnotation', {\n callout: {},\n font: {},\n padding: 6\n });\n }\n },\n\n afterUnregister() {\n Chart.unregister(annotationTypes);\n },\n\n beforeInit(chart) {\n chartStates.set(chart, {\n annotations: [],\n elements: [],\n visibleElements: [],\n listeners: {},\n listened: false,\n moveListened: false\n });\n },\n\n beforeUpdate(chart, args, options) {\n const state = chartStates.get(chart);\n const annotations = state.annotations = [];\n\n let annotationOptions = options.annotations;\n if (isObject(annotationOptions)) {\n Object.keys(annotationOptions).forEach(key => {\n const value = annotationOptions[key];\n if (isObject(value)) {\n value.id = key;\n annotations.push(value);\n }\n });\n } else if (isArray(annotationOptions)) {\n annotations.push(...annotationOptions);\n }\n verifyScaleOptions(annotations, chart.scales);\n },\n\n afterDataLimits(chart, args) {\n const state = chartStates.get(chart);\n adjustScaleRange(chart, args.scale, state.annotations.filter(a => a.display && a.adjustScaleRange));\n },\n\n afterUpdate(chart, args, options) {\n const state = chartStates.get(chart);\n updateListeners(chart, state, options);\n updateElements(chart, state, options, args.mode);\n state.visibleElements = state.elements.filter(el => !el.skip && el.options.display);\n },\n\n beforeDatasetsDraw(chart, _args, options) {\n draw(chart, 'beforeDatasetsDraw', options.clip);\n },\n\n afterDatasetsDraw(chart, _args, options) {\n draw(chart, 'afterDatasetsDraw', options.clip);\n },\n\n beforeDraw(chart, _args, options) {\n draw(chart, 'beforeDraw', options.clip);\n },\n\n afterDraw(chart, _args, options) {\n draw(chart, 'afterDraw', options.clip);\n },\n\n beforeEvent(chart, args, options) {\n const state = chartStates.get(chart);\n handleEvent(state, args.event, options);\n },\n\n destroy(chart) {\n chartStates.delete(chart);\n },\n\n _getState(chart) {\n return chartStates.get(chart);\n },\n\n defaults: {\n animations: {\n numbers: {\n properties: ['x', 'y', 'x2', 'y2', 'width', 'height', 'pointX', 'pointY', 'labelX', 'labelY', 'labelWidth', 'labelHeight', 'radius'],\n type: 'number'\n },\n },\n clip: true,\n dblClickSpeed: 350, // ms\n drawTime: 'afterDatasetsDraw',\n label: {\n drawTime: null\n }\n },\n\n descriptors: {\n _indexable: false,\n _scriptable: (prop) => !hooks.includes(prop),\n annotations: {\n _allKeys: false,\n _fallback: (prop, opts) => `elements.${annotationTypes[resolveType(opts.type)].id}`,\n },\n },\n\n additionalOptionScopes: ['']\n};\n\nfunction draw(chart, caller, clip) {\n const {ctx, chartArea} = chart;\n const {visibleElements} = chartStates.get(chart);\n\n if (clip) {\n clipArea(ctx, chartArea);\n }\n\n drawElements(ctx, visibleElements, caller);\n drawSubElements(ctx, visibleElements, caller);\n\n if (clip) {\n unclipArea(ctx);\n }\n\n visibleElements.forEach(el => {\n if (!('drawLabel' in el)) {\n return;\n }\n const label = el.options.label;\n if (label && label.enabled && label.content && (label.drawTime || el.options.drawTime) === caller) {\n el.drawLabel(ctx, chartArea);\n }\n });\n}\n\nfunction drawElements(ctx, elements, caller) {\n for (const el of elements) {\n if (el.options.drawTime === caller) {\n el.draw(ctx);\n }\n }\n}\n\nfunction drawSubElements(ctx, elements, caller) {\n for (const el of elements) {\n if (isArray(el.elements)) {\n drawElements(ctx, el.elements, caller);\n }\n }\n}\n\nexport { annotation as default };\n","import data from \"./data.json\";\nimport Chart from \"chart.js/auto\";\nimport annotationPlugin from \"chartjs-plugin-annotation\";\n\nChart.register(annotationPlugin);\n\nfunction newShade(hexColor, magnitude) {\n hexColor = hexColor.replace(`#`, ``);\n if (hexColor.length === 6) {\n const decimalColor = parseInt(hexColor, 16);\n let r = (decimalColor >> 16) + magnitude;\n r > 255 && (r = 255);\n r < 0 && (r = 0);\n let g = (decimalColor & 0x0000ff) + magnitude;\n g > 255 && (g = 255);\n g < 0 && (g = 0);\n let b = ((decimalColor >> 8) & 0x00ff) + magnitude;\n b > 255 && (b = 255);\n b < 0 && (b = 0);\n return `#${(g | (b << 8) | (r << 16)).toString(16)}`;\n } else {\n return hexColor;\n }\n}\n\nconst colors = [\n \"#8dd3c7\",\n \"#ffffb3\",\n \"#bebada\",\n \"#fb8072\",\n \"#80b1d3\",\n \"#fdb462\",\n \"#b3de69\",\n \"#fccde5\",\n \"#d9d9d9\",\n \"#bc80bd\",\n \"#ccebc5\",\n \"#ffed6f\",\n];\n\n// https://github.com/chartjs/chartjs-plugin-annotation/blob/752f7e0e6b83f7e606a87ed63720e014f91dd276/docs/samples/line/datasetBars.md?plain=1#L125-L136\nfunction indexToMin(index, datasetCount, datasetIndex) {\n if (datasetCount === 2 && datasetIndex === 1) {\n return index + 0.04;\n }\n return index - 0.36;\n}\n\nfunction indexToMax(index, datasetCount, datasetIndex) {\n if (datasetCount === 2 && datasetIndex === 0) {\n return index - 0.04;\n }\n return index + 0.36;\n}\n\nfunction indexToMid(index, datasetCount, datasetIndex) {\n if (datasetCount === 2) {\n if (datasetIndex === 0) {\n return index - 0.2;\n }\n return index + 0.2;\n }\n return index;\n}\n\nconst stdevLineColor = \"#888888\";\nfor (const graph in data) {\n const ctx = document.getElementById(`${graph}-chart`).getContext(\"2d\");\n const options = {\n animation: false,\n elements: {\n bar: {\n borderWidth: 1.5,\n },\n },\n parsing: {\n xAxisKey: \"id\",\n yAxisKey: \"avg\",\n },\n responsive: true,\n scales: {\n y: {\n beginAtZero: true,\n min: 0,\n title: { text: \"seconds\", display: true },\n },\n },\n plugins: {\n legend: false,\n tooltip: {\n callbacks: {\n label: function (context) {\n return [\n `avg: ${context.raw.avg}`,\n `max: ${context.raw.max}`,\n `min: ${context.raw.min}`,\n ];\n },\n },\n },\n },\n };\n\n data[graph].datasets[0].backgroundColor = [];\n data[graph].datasets[0].borderColor = [];\n data[graph].datasets[0].data.forEach(function (dataset, i) {\n data[graph].datasets[0].backgroundColor.push(colors[i]);\n data[graph].datasets[0].borderColor.push(newShade(colors[i], -50));\n });\n if (data[graph].datasets.length > 1) {\n data[graph].datasets[1].backgroundColor = [];\n data[graph].datasets[1].borderColor = [];\n data[graph].datasets[1].data.forEach(function (dataset, i) {\n data[graph].datasets[1].backgroundColor.push(newShade(colors[i], -30));\n data[graph].datasets[1].borderColor.push(newShade(colors[i], -65));\n });\n options.scales.x = {\n ticks: {\n callback: function (value, index, ticks) {\n return [data[graph].labels[index], \"cold / warm\"];\n },\n },\n };\n }\n\n // TODO: pass in max/min values to show variation in results\n options.plugins.annotation = { annotations: {} };\n for (let idx = 0; idx < data[graph].datasets.length; idx++) {\n for (let idx2 = 0; idx2 < data[graph].datasets[idx].data.length; idx2++) {\n options.plugins.annotation.annotations[`annotations-min-${idx}-${idx2}`] =\n {\n type: \"line\",\n borderColor: stdevLineColor,\n borderWidth: 1.5,\n xMax: indexToMax(idx2, data[graph].datasets.length, idx) - 0.25,\n xMin: indexToMin(idx2, data[graph].datasets.length, idx) + 0.25,\n xScaleID: \"x\",\n // random number between 0 and 100\n yMax: data[graph].datasets[idx].data[idx2].min,\n yMin: data[graph].datasets[idx].data[idx2].min,\n yScaleID: \"y\",\n };\n options.plugins.annotation.annotations[`annotations-max-${idx}-${idx2}`] =\n {\n type: \"line\",\n borderColor: stdevLineColor,\n borderWidth: 1.5,\n xMax: indexToMax(idx2, data[graph].datasets.length, idx) - 0.25,\n xMin: indexToMin(idx2, data[graph].datasets.length, idx) + 0.25,\n xScaleID: \"x\",\n // random number between 0 and 100\n yMax: data[graph].datasets[idx].data[idx2].max,\n yMin: data[graph].datasets[idx].data[idx2].max,\n yScaleID: \"y\",\n };\n const midLine = indexToMid(idx2, data[graph].datasets.length, idx);\n options.plugins.annotation.annotations[\n `annotations-vert-${idx}-${idx2}`\n ] = {\n type: \"line\",\n borderColor: stdevLineColor,\n borderWidth: 1.5,\n xMax: midLine,\n xMin: midLine,\n xScaleID: \"x\",\n // random number between 0 and 100\n yMax: data[graph].datasets[idx].data[idx2].max,\n yMin: data[graph].datasets[idx].data[idx2].min,\n yScaleID: \"y\",\n };\n }\n }\n new Chart(ctx, {\n type: \"bar\",\n data: data[graph],\n options: options,\n });\n}\n"],"names":["$8c325eebeb74625a$exports","JSON","parse","$8d27ca75da600b9c$export$43caf9889c228507","window","callback1","requestAnimationFrame","$8d27ca75da600b9c$export$b4171a6734a65d42","fn","thisArg","updateFn","updateArgs","args","Array","prototype","slice","call","ticking","args1","rest","apply","$8d27ca75da600b9c$export$2219238a014317b0","delay","timeout","clearTimeout","setTimeout","this","$8d27ca75da600b9c$export$34aec0b863436764","align","$8d27ca75da600b9c$export$3c2fa207a37baaea","start","end","$8d27ca75da600b9c$export$91c6e00c14e7e6fd","left","right","rtl","$8d27ca75da600b9c$export$890c4ad488842ce7","$8d27ca75da600b9c$export$555508cbc6add439","id","$8d27ca75da600b9c$export$342063e11d6c3cad","value","$8d27ca75da600b9c$export$8b22cf2602fb60ce","isArray","type","Object","toString","$8d27ca75da600b9c$export$23f2a1d2818174ef","$8d27ca75da600b9c$export$39b482c5e57630a8","Number","isFinite","$8d27ca75da600b9c$export$c4ce752e73470fba","defaultValue","$8d27ca75da600b9c$export$90a7f3efeed30595","$8d27ca75da600b9c$export$7ccc53e8f1e7dfc5","dimension","endsWith","parseFloat","$8d27ca75da600b9c$export$3722cfe417b6ed86","$8d27ca75da600b9c$export$a9c23c6ac3fc3eca","loopable","reverse","i","len","keys","length","$8d27ca75da600b9c$export$ee7c8ad385a60b7b","a0","a1","ilen","v0","v1","datasetIndex","index","$8d27ca75da600b9c$export$c03999cb2f36933f","source","map","target","create","klen","k","$8d27ca75da600b9c$var$isValidKey","key","indexOf","$8d27ca75da600b9c$export$2ed0fc6709e59212","options","tval","sval","$8d27ca75da600b9c$export$6559d589eb85fbb6","sources","merger","$8d27ca75da600b9c$export$7910e0436ed8d1de","$8d27ca75da600b9c$export$f96d196f7728bb5","hasOwnProperty","$8d27ca75da600b9c$var$indexOfDotOrLength","idx","$8d27ca75da600b9c$export$2d1720544b23b823","obj","pos","$8d27ca75da600b9c$export$efca4cbe5dd06740","str","charAt","toUpperCase","$8d27ca75da600b9c$export$35e795649ee09318","$8d27ca75da600b9c$export$2e2af4578d910ddf","$8d27ca75da600b9c$export$c9170ad7d4cd7e57","a","b","size","item","has","$8d27ca75da600b9c$export$995eb9fca571757","e","$8d27ca75da600b9c$export$56c0d5a1e737357d","Math","PI","$8d27ca75da600b9c$export$971d5caa766a69d7","$8d27ca75da600b9c$export$e171bab687b50e0","$8d27ca75da600b9c$export$527e9aa3390079e9","POSITIVE_INFINITY","$8d27ca75da600b9c$export$a17c37559e1db147","$8d27ca75da600b9c$export$7f8ddf7c7c20b3cd","$8d27ca75da600b9c$export$fef3dfd9bad05307","$8d27ca75da600b9c$export$8c78c7c36408ea29","$8d27ca75da600b9c$export$3a1a48c8f6ef640e","log10","$8d27ca75da600b9c$export$2408f22a0fab9ae5","sign","$8d27ca75da600b9c$export$cf2f7c5792f80b46","range","roundedRange","round","$8d27ca75da600b9c$export$a33b77bbdbb8366c","niceRange","pow","floor","fraction","$8d27ca75da600b9c$export$a07804094c3ecf2d","result","sqrt","push","sort","pop","$8d27ca75da600b9c$export$9e5f44173e64f162","n","isNaN","x","y","epsilon","abs","$8d27ca75da600b9c$export$53a70dd1ebbae346","rounded","$8d27ca75da600b9c$export$158acd800e1ef08b","array","property","min","max","$8d27ca75da600b9c$export$625550452a3fa3ec","degrees","$8d27ca75da600b9c$export$25ce5a424b770e84","radians","$8d27ca75da600b9c$export$b9a6b53f9be3734","p","$8d27ca75da600b9c$export$e7094788287c5e9b","centrePoint","anglePoint","distanceFromXCenter","distanceFromYCenter","radialDistanceFromCenter","angle","atan2","distance","$8d27ca75da600b9c$export$24baa2b76016ce0e","pt1","pt2","$8d27ca75da600b9c$export$d29e374196577086","$8d27ca75da600b9c$export$9fa96a7d116ea3ce","$8d27ca75da600b9c$export$ffb5f4729a158638","sameAngleIsFullCircle","s","angleToStart","angleToEnd","startToAngle","endToAngle","$8d27ca75da600b9c$export$efccba1c4a2ef57b","$8d27ca75da600b9c$export$f38c853ae54ed474","$8d27ca75da600b9c$var$atEdge","t","$8d27ca75da600b9c$var$elasticIn","sin","$8d27ca75da600b9c$var$elasticOut","$8d27ca75da600b9c$export$f1e1789686576879","linear","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInSine","cos","easeOutSine","easeInOutSine","easeInExpo","easeOutExpo","easeInOutExpo","easeInCirc","easeOutCirc","easeInOutCirc","easeInElastic","easeOutElastic","easeInOutElastic","easeInBack","easeOutBack","easeInOutBack","easeInBounce","easeOutBounce","m","d","easeInOutBounce","$8d27ca75da600b9c$var$round","v","$8d27ca75da600b9c$var$lim","l","h","$8d27ca75da600b9c$var$p2b","$8d27ca75da600b9c$var$n2b","$8d27ca75da600b9c$var$b2n","$8d27ca75da600b9c$var$n2p","$8d27ca75da600b9c$var$map$1","A","B","C","D","E","F","c","f","$8d27ca75da600b9c$var$hex","$8d27ca75da600b9c$var$h1","$8d27ca75da600b9c$var$h2","$8d27ca75da600b9c$var$eq","$8d27ca75da600b9c$var$hexString","r","g","$8d27ca75da600b9c$var$isShort","$8d27ca75da600b9c$var$alpha","undefined","$8d27ca75da600b9c$var$HUE_RE","$8d27ca75da600b9c$var$hsl2rgbn","$8d27ca75da600b9c$var$hsv2rgbn","$8d27ca75da600b9c$var$hwb2rgbn","w","rgb","$8d27ca75da600b9c$var$rgb2hsl","$8d27ca75da600b9c$var$hueValue","$8d27ca75da600b9c$var$calln","$8d27ca75da600b9c$var$hsl2rgb","$8d27ca75da600b9c$var$hue","$8d27ca75da600b9c$var$hueParse","exec","p1","p2","$8d27ca75da600b9c$var$hwb2rgb","$8d27ca75da600b9c$var$hsv2rgb","$8d27ca75da600b9c$var$map","Z","Y","X","W","V","U","T","S","R","Q","P","O","N","M","L","K","G","H","I","J","$8d27ca75da600b9c$var$names$1","OiceXe","antiquewEte","aqua","aquamarRe","azuY","beige","bisque","black","blanKedOmond","Xe","XeviTet","bPwn","burlywood","caMtXe","KartYuse","KocTate","cSO","cSnflowerXe","cSnsilk","crimson","cyan","xXe","xcyan","xgTMnPd","xWay","xgYF","xgYy","xkhaki","xmagFta","xTivegYF","xSange","xScEd","xYd","xsOmon","xsHgYF","xUXe","xUWay","xUgYy","xQe","xviTet","dAppRk","dApskyXe","dimWay","dimgYy","dodgerXe","fiYbrick","flSOwEte","foYstWAn","fuKsia","gaRsbSo","ghostwEte","gTd","gTMnPd","Way","gYF","gYFLw","gYy","honeyMw","hotpRk","RdianYd","Rdigo","ivSy","khaki","lavFMr","lavFMrXsh","lawngYF","NmoncEffon","ZXe","ZcSO","Zcyan","ZgTMnPdLw","ZWay","ZgYF","ZgYy","ZpRk","ZsOmon","ZsHgYF","ZskyXe","ZUWay","ZUgYy","ZstAlXe","ZLw","lime","limegYF","lRF","magFta","maPon","VaquamarRe","VXe","VScEd","VpurpN","VsHgYF","VUXe","VsprRggYF","VQe","VviTetYd","midnightXe","mRtcYam","mistyPse","moccasR","navajowEte","navy","Tdlace","Tive","TivedBb","Sange","SangeYd","ScEd","pOegTMnPd","pOegYF","pOeQe","pOeviTetYd","papayawEp","pHKpuff","peru","pRk","plum","powMrXe","purpN","YbeccapurpN","Yd","Psybrown","PyOXe","saddNbPwn","sOmon","sandybPwn","sHgYF","sHshell","siFna","silver","skyXe","UXe","UWay","UgYy","snow","sprRggYF","stAlXe","tan","teO","tEstN","tomato","Qe","viTet","JHt","wEte","wEtesmoke","Lw","LwgYF","$8d27ca75da600b9c$var$names","$8d27ca75da600b9c$var$nameParse","unpacked","tkeys","j","ok","nk","replace","parseInt","$8d27ca75da600b9c$var$unpack","transparent","toLowerCase","$8d27ca75da600b9c$var$RGB_RE","$8d27ca75da600b9c$var$to","$8d27ca75da600b9c$var$from","$8d27ca75da600b9c$var$modHSL","ratio","tmp","$8d27ca75da600b9c$var$clone","proto","assign","$8d27ca75da600b9c$var$fromObject","input","$8d27ca75da600b9c$var$functionParse","$8d27ca75da600b9c$var$rgbParse","$8d27ca75da600b9c$var$Color","constructor","ret","_rgb","_valid","valid","rgbString","hexString","hslString","$8d27ca75da600b9c$var$hslString","mix","color1","weight","c1","c2","w2","w1","interpolate","color2","rgb1","rgb2","$8d27ca75da600b9c$var$interpolate","clone","alpha","clearer","greyscale","val","opaquer","negate","lighten","darken","saturate","desaturate","rotate","deg","$8d27ca75da600b9c$var$rotate","$8d27ca75da600b9c$var$index_esm","$8d27ca75da600b9c$export$9f4f30ee63539e24","$8d27ca75da600b9c$export$db3b6bfb95261072","$8d27ca75da600b9c$export$faec65b429be379","$8d27ca75da600b9c$export$ce26c07117d59d6a","$8d27ca75da600b9c$export$a8550f7dbe79f93a","$8d27ca75da600b9c$var$getScope$1","node","split","$8d27ca75da600b9c$var$set","root","scope","values","$8d27ca75da600b9c$export$4368d992c4eafac0","_descriptors1","animation","backgroundColor","borderColor","color","datasets","devicePixelRatio","context","chart","platform","getDevicePixelRatio","elements","events","font","family","style","lineHeight","hover","hoverBackgroundColor","ctx","hoverBorderColor","hoverColor","indexAxis","interaction","mode","intersect","includeInvisible","maintainAspectRatio","onHover","onClick","parsing","plugins","responsive","scale","scales","showLine","drawActiveElementsOnTop","describe","set","get","override","route","name","targetScope","targetName","scopeObject","targetScopeObject","privateName","defineProperties","writable","enumerable","local","_scriptable","startsWith","_indexable","_fallback","$8d27ca75da600b9c$export$3a6d5c9ae78a2c08","data","gc","longest","string","textWidth","measureText","width","$8d27ca75da600b9c$export$a05254e7c3aeba6e","arrayOfThings","cache","garbageCollect","save","jlen","thing","nestedThing","restore","gcLen","splice","$8d27ca75da600b9c$export$71cec2538cb2c617","pixel","currentDevicePixelRatio","halfWidth","$8d27ca75da600b9c$export$f787f51d84a910ad","canvas","getContext","resetTransform","clearRect","height","$8d27ca75da600b9c$export$6554612db691658e","xOffset","yOffset","cornerRadius","pointStyle","rotation","radius","rad","translate","drawImage","beginPath","arc","closePath","moveTo","lineTo","SQRT1_2","rect","fill","borderWidth","stroke","$8d27ca75da600b9c$export$ef35774e6d314e91","point","area","margin","top","bottom","$8d27ca75da600b9c$export$78acf4525d8a74c4","clip","$8d27ca75da600b9c$export$dc98b0b04f4c7758","$8d27ca75da600b9c$export$8a5498727ef6be21","previous","flip","midpoint","$8d27ca75da600b9c$export$d24c54395ce0c509","bezierCurveTo","cp1x","cp2x","cp1y","cp2y","$8d27ca75da600b9c$export$8743009a87fcb00f","text","opts","lines","strokeWidth","strokeColor","line","translation","fillStyle","textAlign","textBaseline","$8d27ca75da600b9c$var$setRenderOpts","strokeStyle","lineWidth","strokeText","maxWidth","fillText","$8d27ca75da600b9c$var$decorateText","strikethrough","underline","metrics","actualBoundingBoxLeft","actualBoundingBoxRight","actualBoundingBoxAscent","actualBoundingBoxDescent","yDecoration","decorationWidth","$8d27ca75da600b9c$export$493d36ec626b6698","topLeft","bottomLeft","bottomRight","topRight","$8d27ca75da600b9c$var$LINE_HEIGHT","RegExp","$8d27ca75da600b9c$var$FONT_STYLE","$8d27ca75da600b9c$export$1a8f5705751d8277","matches","match","$8d27ca75da600b9c$export$3b513254972cfc9c","props","objProps","read","prop","prop1","$8d27ca75da600b9c$export$1fbe638ecf81657e","$8d27ca75da600b9c$export$d66dc83d8cfc8dd","$8d27ca75da600b9c$export$96f57966bedc81b4","$8d27ca75da600b9c$export$3d8c2f653ac9d0b9","fallback","console","warn","$8d27ca75da600b9c$export$d377dcb2b61d6c4e","$8d27ca75da600b9c$export$407448d2b89b1813","inputs","info","cacheable","$8d27ca75da600b9c$export$db202ddc8be9136","minmax","grace","beginAtZero","change","keepZero","add","$8d27ca75da600b9c$export$dda1d9f60106f0e9","parentContext","$8d27ca75da600b9c$export$91477dc880baac21","table","cmp","mid","hi","lo","$8d27ca75da600b9c$export$d141bba7fdc215a3","$8d27ca75da600b9c$export$ebd11618f299a286","$8d27ca75da600b9c$export$23ebac1979863676","$8d27ca75da600b9c$var$arrayEvents","$8d27ca75da600b9c$export$3b14a55fb2447963","listener","stub","_chartjs","listeners","forEach","$8d27ca75da600b9c$export$71511d61b312f219","items","set1","Set","from","$8d27ca75da600b9c$export$c3950d9923825c02","scopes","prefixes","rootScopes","getTarget","$8d27ca75da600b9c$var$_resolve","Symbol","toStringTag","_cacheable","_scopes","_rootScopes","_getTarget","Proxy","deleteProperty","_keys","$8d27ca75da600b9c$var$_cached","proxy","prefix","$8d27ca75da600b9c$var$readKey","$8d27ca75da600b9c$var$needsSubResolver","$8d27ca75da600b9c$var$createSubResolver","$8d27ca75da600b9c$var$_resolveWithPrefixes","getOwnPropertyDescriptor","Reflect","getPrototypeOf","$8d27ca75da600b9c$var$getKeysFromAllScopes","includes","ownKeys","storage","_storage","$8d27ca75da600b9c$export$a93c5207d687da10","subProxy","descriptorDefaults","_proxy","_context","_subProxy","_stack","_descriptors","$8d27ca75da600b9c$export$a9c996f45e5784d0","setContext","receiver","descriptors1","isScriptable","Error","join","delete","$8d27ca75da600b9c$var$_resolveScriptable","isIndexable","descriptors2","arr","filter","resolver","$8d27ca75da600b9c$var$_resolveArray","$8d27ca75da600b9c$var$_resolveWithContext","allKeys","configurable","defaults1","scriptable","indexable","_allKeys","resolve1","$8d27ca75da600b9c$var$resolveFallback","$8d27ca75da600b9c$var$getScope","parent","$8d27ca75da600b9c$var$addScopes","set2","parentScopes","parentFallback","allScopes","set3","$8d27ca75da600b9c$var$addScopesFromKey","$8d27ca75da600b9c$var$subGetTarget","set4","set5","$8d27ca75da600b9c$var$resolveKeysFromAllScopes","$8d27ca75da600b9c$export$4a5767248b18ef41","meta","count","iScale","_parsing","parsed","$8d27ca75da600b9c$var$EPSILON","EPSILON","$8d27ca75da600b9c$var$getPoint","points","skip","$8d27ca75da600b9c$var$getValueAxis","$8d27ca75da600b9c$export$667d3bf0c5f83305","firstPoint","middlePoint","afterPoint","current","next","d01","d12","s01","s12","fa","fb","$8d27ca75da600b9c$export$317a3d46287192d8","valueAxis","pointsLen","deltaK","mK","pointBefore","pointCurrent","pointAfter","slopeDelta","alphaK","betaK","tauK","squaredMagnitude","$8d27ca75da600b9c$var$monotoneAdjust","delta","iPixel","vPixel","$8d27ca75da600b9c$var$monotoneCompute","$8d27ca75da600b9c$var$capControlPoint","pt","$8d27ca75da600b9c$export$21579262ef46735b","loop","controlPoints","spanGaps","cubicInterpolationMode","prev","tension","capBezierPoints","inArea","inAreaPrev","inAreaNext","$8d27ca75da600b9c$var$capBezierPoints","$8d27ca75da600b9c$export$61196ced6d74a310","document","$8d27ca75da600b9c$export$2329c99376c9d0a4","domNode","parentNode","host","$8d27ca75da600b9c$var$parseMaxStyle","styleValue","parentProperty","valueInPixels","$8d27ca75da600b9c$var$getComputedStyle","element","getComputedStyle","$8d27ca75da600b9c$var$positions","$8d27ca75da600b9c$var$getPositionedStyle","styles","suffix","$8d27ca75da600b9c$export$df995fae86a55f06","evt","borderBox","boxSizing","paddings","borders","box","touches","offsetX","offsetY","shadowRoot","$8d27ca75da600b9c$var$useOffsetPos","getBoundingClientRect","clientX","clientY","$8d27ca75da600b9c$var$getCanvasPosition","$8d27ca75da600b9c$var$round1","$8d27ca75da600b9c$export$d66501df72047452","bbWidth","bbHeight","aspectRatio","margins","maxHeight","containerSize","container","containerStyle","containerBorder","containerPadding","clientWidth","clientHeight","$8d27ca75da600b9c$var$getContainerSize","$8d27ca75da600b9c$export$4c3d22f3d993c33f","forceRatio","forceStyle","pixelRatio","deviceHeight","deviceWidth","setTransform","$8d27ca75da600b9c$export$3466f893ebf79586","passiveSupported","passive","addEventListener","removeEventListener","$8d27ca75da600b9c$export$9bb611d729802a56","el","getPropertyValue","$8d27ca75da600b9c$export$1ee57be6f6687d2c","$8d27ca75da600b9c$export$2f6ca3d3b1f80bf5","$8d27ca75da600b9c$export$306ddfe3a8403e2","$8d27ca75da600b9c$export$7a38258bbe170828","cp1","cp2","$8d27ca75da600b9c$var$intlCache","Map","$8d27ca75da600b9c$export$ae1af26003f05816","num","locale","cacheKey","stringify","formatter","Intl","NumberFormat","$8d27ca75da600b9c$var$getNumberFormat","format","$8d27ca75da600b9c$export$28f7fcd39efa255","rectX","setWidth","xPlus","leftForLtr","itemWidth","$8d27ca75da600b9c$var$getRightToLeftAdapter","_itemWidth","$8d27ca75da600b9c$export$3d12bd131bb975d1","direction","original","getPropertyPriority","setProperty","prevTextDirection","$8d27ca75da600b9c$export$9d398bebfec1c039","$8d27ca75da600b9c$var$propertyFn","between","compare","normalize","$8d27ca75da600b9c$var$normalizeSegment","$8d27ca75da600b9c$export$92108d983e8ee699","segment","bounds","startBound","endBound","$8d27ca75da600b9c$var$getSegment","prevValue","inside","subStart","shouldStart","shouldStop","$8d27ca75da600b9c$export$1a82df3d29112e01","segments","sub","$8d27ca75da600b9c$export$ab83b03e4111b1d0","segmentOptions","_loop","$8d27ca75da600b9c$var$findStartAndEnd","$8d27ca75da600b9c$var$splitByStyles","last","cur","stop","$8d27ca75da600b9c$var$solidSegments","_fullLoop","chartContext","_chart","baseStyle","$8d27ca75da600b9c$var$readStyle","_datasetIndex","prevStyle","addStyle","st","dir","p0","p0DataIndex","p1DataIndex","$8d27ca75da600b9c$var$styleChanged","$8d27ca75da600b9c$var$doSplitByStyles","borderCapStyle","borderDash","borderDashOffset","borderJoinStyle","$2e9bc5022d60fc00$export$a424a0aa8f687495","_request","_charts","_running","_lastDate","_notify","anims","date","callbacks","numSteps","duration","initial","currentStep","_refresh","_update","Date","now","remaining","running","draw1","_active","_total","tick","draw","_getAnims","charts","complete","progress","listen","event","cb","reduce","acc","_duration","cancel","remove","$2e9bc5022d60fc00$var$interpolators","boolean","to","factor","c0","number","$2e9bc5022d60fc00$export$c35d437ae5945fcd","cfg","currentValue","_fn","_easing","easing","_start","_target","_prop","_from","_to","_promises","active","update","elapsed","remain","wait","promises","Promise","res","rej","resolved","method","$2e9bc5022d60fc00$var$animationOptions","colors","properties","numbers","resize","show","animations","visible","hide","$2e9bc5022d60fc00$export$8ab227dac26677d","config","_properties","configure","animatedProps","getOwnPropertyNames","option","_animateOptions","newOptions","$shared","$animations","$2e9bc5022d60fc00$var$resolveTargetOptions","_createAnimations","anim","all","$2e9bc5022d60fc00$var$awaitAll","then","$2e9bc5022d60fc00$var$scaleClip","allowedOverflow","$2e9bc5022d60fc00$var$getSortedDatasetIndices","filterVisible","metasets","_getSortedDatasetMetas","$2e9bc5022d60fc00$var$applyStack","stack","dsIndex","singleMode","otherValue","$2e9bc5022d60fc00$var$isStacked","stacked","$2e9bc5022d60fc00$var$getOrCreateStack","stacks","stackKey","indexValue","subStack","$2e9bc5022d60fc00$var$getLastIndexInStack","vScale","positive","getMatchingVisibleMetas","$2e9bc5022d60fc00$var$updateStacks","controller","_cachedMeta","_stacks","iAxis","axis","vAxis","indexScale","valueScale","$2e9bc5022d60fc00$var$getStackKey","index1","_top","_bottom","$2e9bc5022d60fc00$var$getFirstScaleId","scales1","shift","$2e9bc5022d60fc00$var$clearStacks","_parsed","$2e9bc5022d60fc00$var$isDirectUpdateMode","$2e9bc5022d60fc00$var$cloneIfNotShared","cached","shared","$2e9bc5022d60fc00$export$75572ec5c55b4048","_ctx","_cachedDataOpts","getMeta","_type","_data","_objectData","_sharedOptions","_drawStart","_drawCount","enableOptionSharing","supportsDecimation","$context","_syncList","initialize","linkScales","_stacked","addElements","updateIndex","dataset","getDataset","chooseId","xid","xAxisID","yid","yAxisID","rid","rAxisID","iid","iAxisID","vid","vAxisID","xScale","getScaleForId","yScale","rScale","getDatasetMeta","scaleID","_getOtherScale","reset","_destroy","_dataCheck","adata","$2e9bc5022d60fc00$var$convertObjectDataToArray","isExtensible","defineProperty","base","object","datasetElementType","buildOrUpdateElements","resetNewElements","stackChanged","oldStacked","_resyncElements","scopeKeys","datasetScopeKeys","getOptionScopes","createResolver","sorted","_sorted","parseArrayData","parseObjectData","parsePrimitiveData","isNotInOrderComparedToPrev","labels","getLabels","singleScale","index4","index5","xAxisKey","yAxisKey","index6","getParsed","index7","getDataElement","index8","applyStack","updateRangeFromParsed","parsedValue","NaN","getMinMax","canStack","otherScale","hidden","$2e9bc5022d60fc00$var$createStack","NEGATIVE_INFINITY","otherMin","otherMax","minDefined","maxDefined","getUserBounds","$2e9bc5022d60fc00$var$getUserBounds","_skip","getAllParsedValues","getMaxOverflow","getLabelAndValue","index9","label","getLabelForValue","_clip","disabled","$2e9bc5022d60fc00$var$toClip","$2e9bc5022d60fc00$var$defaultClip","elements1","chartArea","getStyle","index10","resolveDatasetElementOptions","resolveDataElementOptions","index11","index3","dataIndex","raw","$2e9bc5022d60fc00$var$createDataContext","index2","_resolveElementOptions","index12","dataElementType","elementType","index13","sharing","datasetElementScopeKeys","names","resolveNamedOptions","freeze","_resolveAnimations","index14","transition","datasetAnimationScopeKeys","getSharedOptions","includeOptions","sharedOptions","_animationsDisabled","updateElement","index15","updateSharedOptions","_setStyle","index16","removeHoverStyle","index17","setHoverStyle","index18","_removeDatasetHoverStyle","_setDatasetHoverStyle","elements2","arg1","arg2","numMeta","numData","_insertElements","_removeElements","move","updateElements","removed","_sync","_dataChanges","_onDataPush","arguments","_onDataPop","_onDataShift","_onDataSplice","newCount","_onDataUnshift","$2e9bc5022d60fc00$var$computeMinSampleSize","_cache","$bar","visibleMetas","concat","$2e9bc5022d60fc00$var$getAllScaleValues","curr","_length","updateMinAndPrev","getPixelForValue","ticks","getPixelForTick","$2e9bc5022d60fc00$var$parseValue","entry","startValue","endValue","barStart","barEnd","_custom","$2e9bc5022d60fc00$var$parseFloatBar","$2e9bc5022d60fc00$var$parseArrayOrPrimitive","$2e9bc5022d60fc00$var$isFloatBar","custom","$2e9bc5022d60fc00$var$setBorderSkipped","index21","edge","borderSkipped","horizontal","$2e9bc5022d60fc00$var$borderProps","enableBorderRadius","$2e9bc5022d60fc00$var$parseEdge","orig","v2","$2e9bc5022d60fc00$var$startEnd","$2e9bc5022d60fc00$var$setInflateAmount","inflateAmount","defaults","$2e9bc5022d60fc00$export$e97d5dc64e999004","iAxisKey","vAxisKey","super","index22","bars","index23","getBasePixel","isHorizontal","ruler","_getRuler","firstOpts","vpixels","head","_calculateBarValuePixels","ipixels","_calculateBarIndexPixels","center","_getStacks","grouped","_getStackCount","index24","_getStackIndex","index25","pixels","barThickness","_startPixel","_endPixel","stackCount","categoryPercentage","barPercentage","index26","baseValue","minBarLength","actualBase","floating","getDataVisibility","$2e9bc5022d60fc00$var$barSign","startPixel","getPixelForDecimal","endPixel","halfGrid","getLineWidthForValue","index27","skipNull","maxBarThickness","Infinity","index20","percent","chunk","$2e9bc5022d60fc00$var$computeFlexCategoryTraits","index19","thickness","$2e9bc5022d60fc00$var$computeFitCategoryTraits","stackIndex","rects","overrides","_index_","offset","grid","_value_","$2e9bc5022d60fc00$export$19b5c4773f17abe","index28","index29","tooltip","title","$2e9bc5022d60fc00$export$e04603e7d8b77172","innerRadius","outerRadius","i1","getter","_getRotation","_getCircumference","circumference","_getRotationExtents","isDatasetVisible","arcs","spacing","getMaxBorderWidth","getMaxOffset","maxSize","cutout","chartWeight","_getRingWeight","ratioX","ratioY","startAngle","endAngle","startX","startY","endX","endY","calcMax","calcMin","maxX","maxY","minX","minY","$2e9bc5022d60fc00$var$getRatioAndOffset","maxRadius","radiusLength","_getVisibleDatasetWeightTotal","total","calculateTotal","_getRingWeightOffset","_circumference","animateRotate","calculateCircumference","animationOpts","centerX","centerY","animateScale","metaData","index30","borderAlign","hoverBorderWidth","hoverOffset","ringWeightOffset","descriptors","legend","generateLabels","legendItem","toggleDataVisibility","tooltipItem","dataLabel","formattedValue","$2e9bc5022d60fc00$export$3c9b5d28c11cbfd0","_dataset","animationsDisabled","pointCount","$2e9bc5022d60fc00$var$getStartAndCountOfVisiblePoints","_scaleRanges","newRanges","xmin","xmax","ymin","ymax","changed","$2e9bc5022d60fc00$var$scaleRangesChanged","_decimated","animated","maxGapLength","directUpdate","prevParsed","nullData","border","lastPoint","updateControlPoints","$2e9bc5022d60fc00$export$2a270b3a0d973c85","index31","bind","_updateRadius","index32","minSize","cutoutPercentage","getVisibleDatasetCount","xCenter","yCenter","datasetStartAngle","getIndexAngle","defaultAngle","countVisibleElements","_computeAngle","getDistanceFromCenterForValue","index33","index34","angleLines","display","circular","pointLabels","$2e9bc5022d60fc00$export$b21a3f1286706191","$2e9bc5022d60fc00$export$48dbc6ac651bf8be","index35","pointPosition","getPointPositionForValue","$2e9bc5022d60fc00$export$b2f2bae6713db87","$2e9bc5022d60fc00$export$a6506504f799c5d5","__proto__","BarController","BubbleController","DoughnutController","LineController","PolarAreaController","PieController","RadarController","ScatterController","$2e9bc5022d60fc00$var$abstract","$2e9bc5022d60fc00$var$DateAdapter","formats","timestamp","amount","unit","diff","startOf","weekday","endOf","members","$2e9bc5022d60fc00$export$f32766ea09ec8bc4","_date","$2e9bc5022d60fc00$var$binarySearch","metaset","lookupMethod","_reversePixels","getRange","$2e9bc5022d60fc00$var$evaluateInteractionItems","position","handler","getSortedVisibleDatasetMetas","index36","$2e9bc5022d60fc00$var$getIntersectItems","useFinalPosition","isPointInArea","index37","inRange","$2e9bc5022d60fc00$var$getNearestCartesianItems","distanceMetric","useX","useY","deltaX","deltaY","$2e9bc5022d60fc00$var$getDistanceMetricForAxis","minDistance","index39","inRange1","getCenterPoint","$2e9bc5022d60fc00$var$getNearestItems","index38","getProps","$2e9bc5022d60fc00$var$getNearestRadialItems","$2e9bc5022d60fc00$var$getAxisItems","rangeMethod","intersectsItem","index40","$2e9bc5022d60fc00$export$a13296960cae0384","modes","elements3","index41","nearest","$2e9bc5022d60fc00$var$STATIC_POSITIONS","$2e9bc5022d60fc00$var$filterByPosition","$2e9bc5022d60fc00$var$filterDynamicPositionByAxis","$2e9bc5022d60fc00$var$sortByWeight","$2e9bc5022d60fc00$var$setLayoutDims","layouts2","params","layouts1","wrap","stackWeight","placed","$2e9bc5022d60fc00$var$buildStacks","vBoxMaxWidth","hBoxMaxHeight","layout","fullSize","availableWidth","availableHeight","$2e9bc5022d60fc00$var$getCombinedMax","maxPadding","$2e9bc5022d60fc00$var$updateMaxPadding","boxPadding","$2e9bc5022d60fc00$var$updateDims","getPadding","newWidth","outerWidth","newHeight","outerHeight","widthChanged","heightChanged","same","other","$2e9bc5022d60fc00$var$getMargins","marginForPositions","positions","$2e9bc5022d60fc00$var$fitBoxes","boxes","refitBoxes","refit","$2e9bc5022d60fc00$var$setBoxDims","$2e9bc5022d60fc00$var$placeBoxes","userPadding","padding","autoPadding","$2e9bc5022d60fc00$export$1ecca0613f5e56d2","addBox","_layers","z","removeBox","layoutItem","index42","minPadding","layoutBoxes","$2e9bc5022d60fc00$var$wrapBoxes","centerHorizontal","centerVertical","leftAndTop","rightAndBottom","vertical","$2e9bc5022d60fc00$var$buildLayoutBoxes","verticalBoxes","horizontalBoxes","beforeLayout","visibleVerticalBoxCount","updatePos","$2e9bc5022d60fc00$var$handleMaxPadding","$2e9bc5022d60fc00$export$7b1aeb87f31f7da8","acquireContext","releaseContext","getMaximumSize","isAttached","updateConfig","$2e9bc5022d60fc00$export$a40a96b24b46cf35","$2e9bc5022d60fc00$var$EVENT_TYPES","touchstart","touchmove","touchend","pointerenter","pointerdown","pointermove","pointerup","pointerleave","pointerout","$2e9bc5022d60fc00$var$isNullOrEmpty","$2e9bc5022d60fc00$var$eventListenerOptions","$2e9bc5022d60fc00$var$removeListener","$2e9bc5022d60fc00$var$nodeListContains","nodeList","contains","$2e9bc5022d60fc00$var$createAttachObserver","observer","MutationObserver","entries","trigger","addedNodes","removedNodes","observe","childList","subtree","$2e9bc5022d60fc00$var$createDetachObserver","$2e9bc5022d60fc00$var$drpListeningCharts","$2e9bc5022d60fc00$var$oldDevicePixelRatio","$2e9bc5022d60fc00$var$onWindowResize","dpr","$2e9bc5022d60fc00$var$createResizeObserver","ResizeObserver","contentRect","$2e9bc5022d60fc00$var$listenDevicePixelRatioChanges","$2e9bc5022d60fc00$var$releaseObserver","disconnect","$2e9bc5022d60fc00$var$unlistenDevicePixelRatioChanges","$2e9bc5022d60fc00$var$createProxyAndListen","native","$2e9bc5022d60fc00$var$fromNativeEvent","$2e9bc5022d60fc00$var$addListener","$2e9bc5022d60fc00$export$f02da7f882cf6b2e","renderHeight","getAttribute","renderWidth","displayWidth","displayHeight","$2e9bc5022d60fc00$var$initCanvas","removeAttribute","setAttribute","proxies","$proxies","attach","detach","isConnected","$2e9bc5022d60fc00$export$db77ccec0bb4ccac","tooltipPosition","hasValue","final","defaultRoutes","$2e9bc5022d60fc00$var$formatters","numeric","tickValue","notation","maxTick","$2e9bc5022d60fc00$var$calculateDelta","logDelta","numDecimal","minimumFractionDigits","maximumFractionDigits","logarithmic","index43","$2e9bc5022d60fc00$export$27c7467594ef87bd","$2e9bc5022d60fc00$var$autoSkip","tickOpts","ticksLimit","maxTicksLimit","tickLength","_tickSize","maxScale","maxChart","_maxLength","$2e9bc5022d60fc00$var$determineMaxTicks","majorIndices","major","enabled","$2e9bc5022d60fc00$var$getMajorIndices","numMajorIndices","first","newTicks","ceil","$2e9bc5022d60fc00$var$skipMajors","evenMajorSpacing","$2e9bc5022d60fc00$var$getEvenSpacing","factors","$2e9bc5022d60fc00$var$calculateSpacing","avgMajorSpacing","$2e9bc5022d60fc00$var$skip","majorStart","majorEnd","drawBorder","drawOnChartArea","drawTicks","tickWidth","tickColor","minRotation","maxRotation","mirror","textStrokeWidth","textStrokeColor","autoSkip","autoSkipPadding","labelOffset","callback","formatters","minor","crossAlign","showLabelBackdrop","backdropColor","backdropPadding","$2e9bc5022d60fc00$var$offsetFromEdge","$2e9bc5022d60fc00$var$sample","numItems","increment","$2e9bc5022d60fc00$var$getPixelForGridLine","index44","offsetGridLines","validIndex1","lineValue","$2e9bc5022d60fc00$var$getTickMarkLength","$2e9bc5022d60fc00$var$getTitleHeight","$2e9bc5022d60fc00$var$titleAlign","$2e9bc5022d60fc00$var$reverseAlign","$2e9bc5022d60fc00$export$d60cfc58d3c358b6","_margins","paddingTop","paddingBottom","paddingLeft","paddingRight","labelRotation","_range","_gridLineItems","_labelItems","_labelSizes","_longestTextCache","_userMax","_userMin","_suggestedMax","_suggestedMin","_ticksLength","_borderValue","_dataLimitsCached","init","suggestedMin","suggestedMax","metas","getTicks","xLabels","yLabels","beforeUpdate","sampleSize","beforeSetDimensions","setDimensions","afterSetDimensions","beforeDataLimits","determineDataLimits","afterDataLimits","beforeBuildTicks","buildTicks","afterBuildTicks","samplingEnabled","_convertTicksToLabels","beforeCalculateLabelRotation","calculateLabelRotation","afterCalculateLabelRotation","afterAutoSkip","beforeFit","fit","afterFit","afterUpdate","reversePixels","_alignToPixels","alignToPixels","_callHooks","notifyPlugins","beforeTickToLabelConversion","generateTickLabels","afterTickToLabelConversion","numTicks","maxLabelDiagonal","_isVisible","labelSizes","_getLabelSizes","maxLabelWidth","widest","maxLabelHeight","highest","asin","titleOpts","gridOpts","titleHeight","tickPadding","angleRadians","labelHeight","labelWidth","_calculatePadding","_handleMargins","isRotated","labelsBelowTicks","offsetLeft","offsetRight","isFullSize","_computeLabelSizes","caches","widths","heights","tickFont","fontString","nestedLabel","widestLabelSize","highestLabelSize","_resolveTickFontOptions","$2e9bc5022d60fc00$var$garbageCollect","valueAt","getValueForPixel","index46","decimal","getDecimalForPixel","getBaseValue","index47","index45","$2e9bc5022d60fc00$var$createTickContext","optionTicks","rot","_computeGridLineItems","ticksLength","tl","borderOpts","axisWidth","axisHalfWidth","alignBorderValue","borderValue","alignedLineValue","tx1","ty1","tx2","ty2","x1","y1","x2","y2","positionAxisID","limit","step","optsAtIndex","lineColor","tickBorderDash","tickBorderDashOffset","_computeLabelItems","tickAndPadding","hTickAndPadding","lineCount","textOffset","_getXAxisLabelAlignment","_getYAxisLabelAlignment","halfCount","backdrop","tickTextAlign","labelPadding","_computeLabelArea","drawBackground","fillRect","index48","findIndex","drawGrid","drawLine","setLineDash","lineDashOffset","lastLineWidth","drawLabels","drawTitle","titleX","titleY","scales2","$2e9bc5022d60fc00$var$titleArgs","tz","gz","axisID","index49","_maxDigits","fontSize","$2e9bc5022d60fc00$var$TypedRegistry","isForType","isPrototypeOf","register","parentScope","$2e9bc5022d60fc00$var$isIChartComponent","itemDefaults","routes","propertyParts","sourceName","sourceScope","parts","$2e9bc5022d60fc00$var$routeDefaults","$2e9bc5022d60fc00$var$registerDefaults","unregister","$2e9bc5022d60fc00$export$4bb7493d241fd8a5","controllers","_typedRegistries","_each","addControllers","addPlugins","addScales","getController","_get","getElement","getPlugin","getScale","removeControllers","removeElements","removePlugins","removeScales","typedRegistry","arg","reg","_getRegistryForType","_exec","itemReg","registry1","component","camelMethod","$2e9bc5022d60fc00$var$PluginService","_init","notify","hook","_createDescriptors","descriptor","plugin","cancelable","invalidate","_oldCache","descriptors3","_notifyStateChanges","plugins1","plugins2","i3","$2e9bc5022d60fc00$var$allPlugins","plugins3","$2e9bc5022d60fc00$var$getOpts","$2e9bc5022d60fc00$var$pluginOpts","$2e9bc5022d60fc00$var$createDescriptors","previousDescriptors","descriptors4","some","pluginScopeKeys","$2e9bc5022d60fc00$var$getIndexAxis","datasetDefaults","$2e9bc5022d60fc00$var$determineAxis","scaleOptions","$2e9bc5022d60fc00$var$initOptions","chartDefaults","configScales","chartIndexAxis","firstIDs","scales3","scaleConf","error","defaultId","$2e9bc5022d60fc00$var$getDefaultScaleIDFromAxis","defaultScaleOptions","defaultID","$2e9bc5022d60fc00$var$getAxisFromDefaultScaleID","$2e9bc5022d60fc00$var$mergeScaleConfig","$2e9bc5022d60fc00$var$initData","$2e9bc5022d60fc00$var$keyCache","$2e9bc5022d60fc00$var$keysCached","$2e9bc5022d60fc00$var$cachedKeys","generate","$2e9bc5022d60fc00$var$addIfFound","$2e9bc5022d60fc00$var$Config","_config","$2e9bc5022d60fc00$var$initConfig","_scopeCache","_resolverCache","clearCache","clear","datasetType","additionalOptionScopes","_cachedScopes","mainScope","resetCache","keyLists","chartOptionScopes","subPrefixes","$2e9bc5022d60fc00$var$getResolver","$2e9bc5022d60fc00$var$hasFunction","$2e9bc5022d60fc00$var$needContext","resolverCache","$2e9bc5022d60fc00$var$KNOWN_POSITIONS","$2e9bc5022d60fc00$var$positionIsHorizontal","$2e9bc5022d60fc00$var$compare2Level","l1","l2","$2e9bc5022d60fc00$var$onAnimationsComplete","animationOptions1","onComplete","$2e9bc5022d60fc00$var$onAnimationProgress","animationOptions2","onProgress","$2e9bc5022d60fc00$var$getCanvas","getElementById","$2e9bc5022d60fc00$var$instances","$2e9bc5022d60fc00$var$getChart","$2e9bc5022d60fc00$var$moveNumericKeys","intKey","$2e9bc5022d60fc00$export$acaa6426d77a227e","userConfig","initialCanvas","existingChart","OffscreenCanvas","$2e9bc5022d60fc00$export$72cd9e67b1b784f9","_options","_aspectRatio","_metasets","_lastEvent","_listeners","_responsiveListeners","_sortedMetasets","_plugins","_hiddenIndices","attached","_doResize","resizeDelay","_initialize","bindEvents","_resizeBeforeDraw","_resize","newSize","newRatio","onResize","render","ensureScalesHaveIDs","axisOptions","buildOrUpdateScales","scaleOpts","scales4","updated","isRadial","dposition","dtype","scaleType","hasUpdated","_updateMetasets","_destroyDatasetMeta","_removeUnreferencedMetasets","index50","buildOrUpdateControllers","newControllers","order","ControllerClass","_resetElements","animsDisabled","_updateScales","_checkEventBindings","_updateHiddenIndices","_minPadding","_updateLayout","_updateDatasets","_eventHandler","_updateHoverStyles","existingEvents","newEvents","unbindEvents","changes","_getUniformDataChanges","datasetCount","makeSet","changeSet","i4","noArea","index51","_idx","i5","ilen1","_updateDataset","index52","layers","_drawDatasets","_drawDataset","useClip","getElementsAtEventForMode","setDatasetVisibility","index53","index54","_updateVisibility","_stop","destroy","toBase64Image","toDataURL","bindUserEvents","bindResponsiveEvents","_add","listener1","_remove","listener2","detached","updateHoverStyle","getActiveElements","setActiveElements","activeElements","lastActive","index55","replay","hoverOptions","deactivated","activated","inChartArea","eventFilter","_handleEvent","_getActiveElements","isClick","lastEvent","$2e9bc5022d60fc00$var$determineLastEvent","$2e9bc5022d60fc00$var$invalidatePlugins","instances","$2e9bc5022d60fc00$var$clipArc","pixelMargin","angleMargin","$2e9bc5022d60fc00$var$parseBorderRadius$1","angleDelta","o","borderRadius","halfThickness","innerLimit","computeOuterLimit","outerArcLimit","outerStart","outerEnd","innerStart","innerEnd","$2e9bc5022d60fc00$var$rThetaToXY","theta","$2e9bc5022d60fc00$var$pathArc","innerR","spacingOffset","avNogSpacingRadius","angleOffset","outerStartAdjustedRadius","outerEndAdjustedRadius","outerStartAdjustedAngle","outerEndAdjustedAngle","innerStartAdjustedRadius","innerEndAdjustedRadius","innerStartAdjustedAngle","innerEndAdjustedAngle","pCenter","p4","p8","$2e9bc5022d60fc00$var$drawBorder","inner","lineJoin","fullCircles","$2e9bc5022d60fc00$var$drawFullCircleBorders","registry","version","getChart","$2e9bc5022d60fc00$export$d48203c759d6a1fc","chartX","chartY","rAdjust","betweenAngles","withinRadius","halfAngle","halfRadius","radiusOffset","$2e9bc5022d60fc00$var$drawArc","$2e9bc5022d60fc00$var$setStyle","lineCap","$2e9bc5022d60fc00$var$lineTo","$2e9bc5022d60fc00$var$pathVars","paramsStart","paramsEnd","segmentStart","segmentEnd","outside","$2e9bc5022d60fc00$var$pathSegment","lineMethod","stepped","$2e9bc5022d60fc00$var$getLineMethod","$2e9bc5022d60fc00$var$fastPathSegment","prevX","lastY","avgX","countX","pointIndex","index56","drawX","truncX","$2e9bc5022d60fc00$var$_getSegmentMethod","$2e9bc5022d60fc00$var$usePath2D","Path2D","$2e9bc5022d60fc00$var$draw","path","_path","$2e9bc5022d60fc00$var$strokePathWithCache","segmentMethod","$2e9bc5022d60fc00$var$strokePathDirect","$2e9bc5022d60fc00$export$55e463fa7bcd3469","_points","_segments","_pointsUpdated","_interpolate","$2e9bc5022d60fc00$var$_getInterpolationMethod","interpolated","pathSegment","$2e9bc5022d60fc00$var$inRange$1","hitRadius","$2e9bc5022d60fc00$export$bd159b522b230b7a","mouseX","mouseY","inXRange","inYRange","hoverRadius","$2e9bc5022d60fc00$var$getBarBounds","bar","half","$2e9bc5022d60fc00$var$skipOrLimit","skip1","$2e9bc5022d60fc00$var$boundingRects","maxW","maxH","skip2","$2e9bc5022d60fc00$var$parseBorderWidth","maxR","skip3","enableBorder","$2e9bc5022d60fc00$var$parseBorderRadius","outer","$2e9bc5022d60fc00$var$inRange","skipX","skipY","$2e9bc5022d60fc00$var$addNormalRectPath","$2e9bc5022d60fc00$var$inflateRect","refRect","$2e9bc5022d60fc00$export$a16ed71bf4b07672","addRectPath","$2e9bc5022d60fc00$export$7a5d735b2ab6389d","ArcElement","LineElement","PointElement","BarElement","$2e9bc5022d60fc00$var$cleanDecimatedDataset","$2e9bc5022d60fc00$var$cleanDecimatedData","$2e9bc5022d60fc00$export$be17f937e9aa7533","algorithm","beforeElementsUpdate","xAxis","$2e9bc5022d60fc00$var$getStartAndCountOfVisiblePointsSimplified","threshold","decimated","samples","bucketWidth","sampledIndex","endIndex","maxAreaPoint","maxArea","nextA","avgY","avgRangeStart","avgRangeEnd","avgRangeLength","rangeOffs","rangeTo","pointAx","pointAy","$2e9bc5022d60fc00$var$lttbDecimation","minIndex","maxIndex","startIndex","xMin","dx","lastIndex","intermediateIndex1","intermediateIndex2","$2e9bc5022d60fc00$var$minMaxDecimation","$2e9bc5022d60fc00$var$_getBounds","$2e9bc5022d60fc00$var$_findSegmentEnd","$2e9bc5022d60fc00$var$_getEdge","$2e9bc5022d60fc00$var$_createBoundaryLine","boundary","linePoints","$2e9bc5022d60fc00$var$_pointsFromSegments","$2e9bc5022d60fc00$var$_resolveTarget","index57","propagate","fill1","visited","$2e9bc5022d60fc00$var$_decodeFill","index58","fill2","fillOption","fill5","$2e9bc5022d60fc00$var$parseFillOption","firstCh","index59","$2e9bc5022d60fc00$var$decodeTargetIndex","$2e9bc5022d60fc00$var$addPointsBelow","sourcePoint","linesBelow","postponed","$2e9bc5022d60fc00$var$findPoint","unshift","pointValue","firstValue","lastValue","$2e9bc5022d60fc00$var$simpleArc","$2e9bc5022d60fc00$var$_getTarget","fill6","index62","$2e9bc5022d60fc00$var$getLineByIndex","index60","sourcePoints","index61","below","$2e9bc5022d60fc00$var$getLinesBelow","$2e9bc5022d60fc00$var$_buildStackLine","fill8","fill4","$2e9bc5022d60fc00$var$_getTargetValue","$2e9bc5022d60fc00$var$computeCircularBoundary","fill7","fill3","$2e9bc5022d60fc00$var$_getTargetPixel","$2e9bc5022d60fc00$var$computeLinearBoundary","$2e9bc5022d60fc00$var$computeBoundary","$2e9bc5022d60fc00$var$_drawfill","lineOpts","above","$2e9bc5022d60fc00$var$clipVertical","$2e9bc5022d60fc00$var$fill","$2e9bc5022d60fc00$var$doFill","clipY","lineLoop","color3","tpoints","targetSegments","tgt","subBounds","fillSources","fillSource","$2e9bc5022d60fc00$var$_segments","src","notShape","$2e9bc5022d60fc00$var$clipBounds","$2e9bc5022d60fc00$var$interpolatedLineTo","targetLoop","interpolatedPoint","$2e9bc5022d60fc00$export$d19ba4d812bed757","afterDatasetsUpdate","_args","$filler","beforeDraw","draw2","drawTime","beforeDatasetsDraw","beforeDatasetDraw","$2e9bc5022d60fc00$var$getBoxSize","labelOpts","boxHeight","boxWidth","usePointStyle","itemHeight","$2e9bc5022d60fc00$var$Legend","_added","legendHitBoxes","_hoveredItem","doughnutMode","legendItems","columnSizes","lineWidths","buildLabels","labelFont","_computeTitleHeight","_fitRows","_fitCols","hitboxes","totalHeight","row","heightLimit","totalWidth","currentColWidth","currentColHeight","col","adjustHitBoxes","rtlHelper","hitbox","_draw","defaultColor","fontColor","halfFontSize","cursor","textDirection","lineDash","drawOptions","SQRT2","yBoxTop","xBoxLeft","drawLegendBox","titleFont","titlePadding","topPaddingPlusHalfFontSize","_getLegendItemAt","hitBox","lh","handleEvent","onLeave","$2e9bc5022d60fc00$var$isListened","hoveredItem","sameItem","$2e9bc5022d60fc00$export$ed247974535929c7","_element","afterEvent","index63","ci","color4","$2e9bc5022d60fc00$var$Title","_padding","textSize","_drawArgs","fontOpts","$2e9bc5022d60fc00$export$f99233281efd08a0","titleBlock","$2e9bc5022d60fc00$var$createTitle","$2e9bc5022d60fc00$var$map","WeakMap","$2e9bc5022d60fc00$export$d5c56664638992a4","$2e9bc5022d60fc00$var$positioners","average","eventPosition","nearestElement","tp","$2e9bc5022d60fc00$var$pushOrConcat","toPush","$2e9bc5022d60fc00$var$splitNewlines","String","$2e9bc5022d60fc00$var$createTooltipItem","index64","$2e9bc5022d60fc00$var$getTooltipSize","body","footer","bodyFont","footerFont","titleLineCount","footerLineCount","bodyLineItemCount","combinedBodyLength","bodyItem","before","after","beforeBody","afterBody","titleSpacing","titleMarginBottom","displayColors","bodySpacing","footerMarginTop","footerSpacing","widthPadding","maxLineWidth","$2e9bc5022d60fc00$var$determineXAlign","yAlign","chartWidth","xAlign","caret","caretSize","caretPadding","$2e9bc5022d60fc00$var$doesNotFitWithAlign","$2e9bc5022d60fc00$var$determineAlignment","$2e9bc5022d60fc00$var$determineYAlign","$2e9bc5022d60fc00$var$getBackgroundPoint","alignment","paddingAndSize","$2e9bc5022d60fc00$var$alignX","$2e9bc5022d60fc00$var$alignY","$2e9bc5022d60fc00$var$getAlignedX","$2e9bc5022d60fc00$var$getBeforeAfterBodyLines","$2e9bc5022d60fc00$var$overrideCallbacks","$2e9bc5022d60fc00$var$Tooltip","opacity","_eventPosition","_size","_cachedAnimations","_tooltipItems","dataPoints","caretX","caretY","labelColors","labelPointStyles","labelTextColors","tooltipItems","getTitle","beforeTitle","afterTitle","getBeforeBody","getBody","bodyItems","scoped","beforeLabel","afterLabel","getAfterBody","getFooter","beforeFooter","afterFooter","_createItems","index65","itemSort","labelColor","labelPointStyle","labelTextColor","positionAndSize","backgroundPoint","external","drawCaret","tooltipPoint","caretPosition","getCaretPosition","x3","y3","ptX","ptY","titleAlign","titleColor","_drawColorBox","colorX","rtlColorX","yOffSet","colorY","multiKeyBackground","outerX","innerX","strokeRect","drawBody","bodyAlign","bodyLineHeight","xLinePadding","fillLineOfText","bodyAlignForCalculation","textColor","bodyColor","drawFooter","footerAlign","footerColor","tooltipSize","quadraticCurveTo","_updateAnimationTarget","animX","animY","_willRender","hasTooltipContent","globalAlpha","index66","positionChanged","_positionChanged","_ignoreReplayEvents","positioners","$2e9bc5022d60fc00$export$28c660c63b792dea","afterInit","afterDraw","labelCount","$2e9bc5022d60fc00$export$8b3ca321c77fdea6","Decimation","Filler","Legend","SubTitle","Title","Tooltip","$2e9bc5022d60fc00$var$findOrAddLabel","index68","addedLabels","index67","$2e9bc5022d60fc00$var$addIfString","lastIndexOf","$2e9bc5022d60fc00$export$29e663ba4d09fe7","_startValue","_valueRange","_addedLabels","added","index70","index71","index69","index72","$2e9bc5022d60fc00$var$generateTicks$1","generationOptions","dataRange","precision","maxTicks","maxDigits","includeBounds","maxSpaces","rmin","rmax","countDefined","minSpacing","niceMin","niceMax","numSpaces","decimalPlaces","$2e9bc5022d60fc00$var$relativeLabelSize","$2e9bc5022d60fc00$var$LinearScaleBase","_endValue","handleTickRangeOptions","setMin","setMax","minSign","maxSign","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","getTickLimit","stepSize","computeTickLimit","$2e9bc5022d60fc00$export$e7f4e5e8656f0b93","$2e9bc5022d60fc00$var$isMajor","tickVal","$2e9bc5022d60fc00$export$85295eaf7cb3ac3e","index73","_zero","exp","endExp","endSignificand","significand","lastTick","$2e9bc5022d60fc00$var$generateTicks","$2e9bc5022d60fc00$var$getTickBackdropHeight","$2e9bc5022d60fc00$var$determineLimits","$2e9bc5022d60fc00$var$fitWithPointLabels","limits","valueCount","_pointLabels","pointLabelOpts","additionalAngle","centerPointLabels","getPointLabelContext","getPointPosition","drawingArea","plFont","$2e9bc5022d60fc00$var$updateLimits","setCenterPoint","_pointLabelItems","extra","outerDistance","pointLabelPosition","$2e9bc5022d60fc00$var$yForAngle","$2e9bc5022d60fc00$var$getTextAlignForAngle","$2e9bc5022d60fc00$var$leftForTextAlign","$2e9bc5022d60fc00$var$buildPointLabelItems","hLimits","vLimits","$2e9bc5022d60fc00$var$pathRadiusLine","$2e9bc5022d60fc00$export$cfafc36d95386d38","index75","leftMovement","rightMovement","topMovement","bottomMovement","index76","scalingFactor","getValueForDistanceFromCenter","scaledDistance","index77","pointLabel","index78","distanceFromCenter","index79","getBasePosition","index80","getPointLabelPosition","index81","backdropLeft","backdropTop","backdropWidth","backdropHeight","$2e9bc5022d60fc00$var$drawPointLabels","index82","gridLineOpts","color5","$2e9bc5022d60fc00$var$drawRadiusLine","color6","index83","animate","$2e9bc5022d60fc00$var$INTERVALS","millisecond","common","steps","second","minute","hour","day","week","month","quarter","year","$2e9bc5022d60fc00$var$UNITS","$2e9bc5022d60fc00$var$sorter","$2e9bc5022d60fc00$var$parse","adapter","_adapter","parser","isoWeekday","_parseOpts","$2e9bc5022d60fc00$var$determineUnitForAutoTicks","minUnit","capacity","interval","$2e9bc5022d60fc00$var$addTick","time","timestamps","$2e9bc5022d60fc00$var$ticksFromTimestamps","majorUnit","map2","map1","index84","$2e9bc5022d60fc00$var$setMajorTicks","$2e9bc5022d60fc00$export$a894c72689ff3ec","_unit","_majorUnit","_offsets","_normalized","adapters","displayFormats","normalized","_applyBounds","_getLabelBounds","getLabelTimestamps","timeOpts","_generate","_getLabelCapacity","$2e9bc5022d60fc00$var$determineUnitForFormatting","$2e9bc5022d60fc00$var$determineMajorUnit","initOffsets","offsetAfterAutoskip","getDecimalForValue","hasWeekday","getDataTimestamps","tooltipFormat","datetime","_tickFormatFunction","index85","minorFormat","majorFormat","offsets","_getLabelSize","ticksOpts","tickLabelWidth","cosRotation","sinRotation","tickFontSize","exampleTime","exampleLabel","$2e9bc5022d60fc00$var$interpolate","prevSource","nextSource","prevTarget","nextTarget","span","$2e9bc5022d60fc00$export$85df64a8eb6dc986","_table","_minPos","_tableRange","_getTimestampsForTable","buildLookupTable","CategoryScale","LinearScale","LogarithmicScale","RadialLinearScale","TimeScale","TimeSeriesScale","$cf422c3a51eae3ca$export$2e2bcd8739ae039","$4049e6bf31df43d6$var$clickHooks","$4049e6bf31df43d6$var$moveHooks","$4049e6bf31df43d6$var$hooks","$4049e6bf31df43d6$var$handleEvent","state","listened","moveListened","$4049e6bf31df43d6$var$getNearestItem","hovered","$4049e6bf31df43d6$var$dispatchEvent","leave","enter","$4049e6bf31df43d6$var$dispatchMoveEvents","$4049e6bf31df43d6$var$handleMoveEvents","elOpts","dblclick","click","clickTimeout","dblClickSpeed","$4049e6bf31df43d6$var$handleClickEvents","nearestItems","_index","$4049e6bf31df43d6$var$adjustScaleRange","annotations","scaleIDOption","annotation4","$4049e6bf31df43d6$var$updateLimits","$4049e6bf31df43d6$var$getScaleLimits","$4049e6bf31df43d6$var$changeScaleLimit","suggestedLimit","$4049e6bf31df43d6$var$scaleLimitDefined","$4049e6bf31df43d6$var$verifyScaleIDs","annotation2","$4049e6bf31df43d6$var$verifyProperties","annotation3","annotation5","$4049e6bf31df43d6$var$clamp","$4049e6bf31df43d6$var$clampAll","$4049e6bf31df43d6$var$inBoxRange","hBorderWidth","$4049e6bf31df43d6$var$getElementCenterPoint","$4049e6bf31df43d6$var$isOlderPart","act","req","substr","$4049e6bf31df43d6$var$isPercentString","$4049e6bf31df43d6$var$toPercent","$4049e6bf31df43d6$var$getRelativePosition","positionOption","$4049e6bf31df43d6$var$getSize","$4049e6bf31df43d6$var$toPosition","$4049e6bf31df43d6$var$isBoundToPoint","xValue","yValue","$4049e6bf31df43d6$var$widthCache","$4049e6bf31df43d6$var$isImageOrCanvas","content","$4049e6bf31df43d6$var$translate","$4049e6bf31df43d6$var$setBorderStyle","$4049e6bf31df43d6$var$setShadowStyle","shadowColor","backgroundShadowColor","shadowBlur","shadowOffsetX","shadowOffsetY","$4049e6bf31df43d6$var$measureLabelSize","mapKey","_measureText","$4049e6bf31df43d6$var$drawBox","borderShadowColor","$4049e6bf31df43d6$var$drawLabel","$4049e6bf31df43d6$var$calculateTextAlignment","miterLimit","$4049e6bf31df43d6$var$setTextStrokeStyle","$4049e6bf31df43d6$var$getRectCenterPoint","$4049e6bf31df43d6$var$rotated","cx","cy","$4049e6bf31df43d6$var$scaleValue","$4049e6bf31df43d6$var$getChartDimensionByScale","$4049e6bf31df43d6$var$getChartPoint","xScaleID","yScaleID","$4049e6bf31df43d6$var$getChartRect","xDim","xMax","yDim","yMin","yMax","$4049e6bf31df43d6$var$resolvePointPosition","xAdjust","yAdjust","$4049e6bf31df43d6$var$getChartCircle","$4049e6bf31df43d6$var$BoxAnnotation","drawLabel","halfBorder","labelSize","labelRect","$4049e6bf31df43d6$var$calculateX","$4049e6bf31df43d6$var$calculateY","resolveElementProperties","adjust","$4049e6bf31df43d6$var$calculatePosition$1","boxOpts","padStart","padEnd","adjustScaleRange","$4049e6bf31df43d6$var$pointInLine","$4049e6bf31df43d6$var$interpolateX","$4049e6bf31df43d6$var$interpolateY","$4049e6bf31df43d6$var$sqr","$4049e6bf31df43d6$var$isLineInArea","$4049e6bf31df43d6$var$limitPointToArea","$4049e6bf31df43d6$var$LineAnnotation","intersects","dy","lenSq","xx","yy","labelIsVisible","isOnLabel","labelX","labelY","h2","startOpts","endOpts","startAdjust","endAdjust","arrowStartOpts","arrowHeads","arrowEndOpts","$4049e6bf31df43d6$var$getLineAdjust","$4049e6bf31df43d6$var$getArrowHeads","$4049e6bf31df43d6$var$drawArrowHead","labelTextSize","$4049e6bf31df43d6$var$limitLineToArea","lblPadding","xPadding","yPadding","tempPadding","$4049e6bf31df43d6$var$getPadding","sizes","$4049e6bf31df43d6$var$calculateAutoRotation","$4049e6bf31df43d6$var$rotatedSize","space","$4049e6bf31df43d6$var$spaceAround","$4049e6bf31df43d6$var$calculateTAdjust","$4049e6bf31df43d6$var$calculateT","xCoordinateSizes","yCoordinateSizes","$4049e6bf31df43d6$var$adjustLabelCoordinate","$4049e6bf31df43d6$var$calculateLabelPosition","$4049e6bf31df43d6$var$loadLabelRect","$4049e6bf31df43d6$var$arrowHeadsDefaults","lineSize","lineW","lineH","coordinate","halfSize","arrowOpts","arrowOffsetX","$4049e6bf31df43d6$var$EllipseAnnotation","ellipse","xRadius","yRadius","cosAngle","sinAngle","$4049e6bf31df43d6$var$pointInEllipse","$4049e6bf31df43d6$var$LabelAnnotation","pointX","pointY","calloutPosition","callout","separatorStart","separatorEnd","$4049e6bf31df43d6$var$getCalloutSeparatorAdjust","$4049e6bf31df43d6$var$getCalloutSeparatorCoord","sideStart","sideEnd","side","$4049e6bf31df43d6$var$getCalloutSideAdjust","$4049e6bf31df43d6$var$getCalloutSideCoord","rotatedPoint","$4049e6bf31df43d6$var$drawCallout","boxSize","$4049e6bf31df43d6$var$calculatePosition","$4049e6bf31df43d6$var$measureRect","xPoints","yPoints","$4049e6bf31df43d6$var$positions","$4049e6bf31df43d6$var$resolveCalloutAutoPosition","$4049e6bf31df43d6$var$resolveCalloutPosition","$4049e6bf31df43d6$var$PointAnnotation","$4049e6bf31df43d6$var$inPointRange","$4049e6bf31df43d6$var$PolygonAnnotation","isInside","bY","bX","$4049e6bf31df43d6$var$pointIsInPolygon","sides","optionScope","initProperties","$4049e6bf31df43d6$var$annotationTypes","polygon","$4049e6bf31df43d6$var$directUpdater","$4049e6bf31df43d6$var$resolveType","$4049e6bf31df43d6$var$updateElements","animOpts","$4049e6bf31df43d6$var$resolveAnimations","$4049e6bf31df43d6$var$resyncElements","annotationOptions","$4049e6bf31df43d6$var$getOrCreateElement","$4049e6bf31df43d6$var$getContext","$4049e6bf31df43d6$var$toSkip","$4049e6bf31df43d6$var$updateSubElements","$4049e6bf31df43d6$var$resolveAnnotationOptions","mainElement","subElements","definition","subElement","subResolver","elementClass","$4049e6bf31df43d6$var$resolveObj","defs","optDefs","annotation6","$4049e6bf31df43d6$var$chartStates","$4049e6bf31df43d6$var$draw","caller","visibleElements","$4049e6bf31df43d6$var$drawElements","$4049e6bf31df43d6$var$drawSubElements","$dad545c909cfec2d$var$newShade","hexColor","magnitude","decimalColor","afterRegister","pkg","ver","strict","$4049e6bf31df43d6$var$requireVersion","afterUnregister","beforeInit","annotation1","$4049e6bf31df43d6$var$verifyScaleOptions","$4049e6bf31df43d6$var$updateListeners","afterDatasetsDraw","beforeEvent","_getState","$dad545c909cfec2d$var$colors","$dad545c909cfec2d$var$indexToMin","$dad545c909cfec2d$var$indexToMax","graph","$parcel$interopDefault","avg","annotation","idx2","midLine"],"version":3,"file":"index.450a67f6.js.map"} \ No newline at end of file diff --git a/index.450a67f6.js b/index.92b3d5d1.js similarity index 96% rename from index.450a67f6.js rename to index.92b3d5d1.js index 268fac9b..50799f25 100644 --- a/index.450a67f6.js +++ b/index.92b3d5d1.js @@ -1,4 +1,4 @@ -function t(t){return t&&t.__esModule?t.default:t}var e;e=JSON.parse('{"lock":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"72.59","min":"70.1","avg":"71.74"},{"id":"pip-tools 7.4.1","max":"31.17","min":"28.22","avg":"29.87"},{"id":"pipenv 2024.2.0","max":"46.71","min":"43.69","avg":"45.83"},{"id":"poetry 1.8.4","max":"18.56","min":"15.51","avg":"17.2"},{"id":"uv 0.4.27","max":"2.15","min":"1.78","avg":"2.03"}],"label":"cold"},{"data":[{"id":"pdm 2.19.3","max":"66.39","min":"64.62","avg":"65.13"},{"id":"pip-tools 7.4.1","max":"24.61","min":"22.4","avg":"23.43"},{"id":"pipenv 2024.2.0","max":"41.41","min":"38.78","avg":"39.97"},{"id":"poetry 1.8.4","max":"8.02","min":"7.33","avg":"7.64"},{"id":"uv 0.4.27","max":"0.12","min":"0.11","avg":"0.11"}],"label":"warm"}]},"install":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"43.72","min":"39.6","avg":"41.27"},{"id":"pip-tools 7.4.1","max":"53.85","min":"45.82","avg":"48.95"},{"id":"pipenv 2024.2.0","max":"42.68","min":"41.52","avg":"42.29"},{"id":"poetry 1.8.4","max":"27.39","min":"25.9","avg":"26.6"},{"id":"uv 0.4.27","max":"20.88","min":"18.69","avg":"19.55"}],"label":"cold"},{"data":[{"id":"pdm 2.19.3","max":"26.0","min":"25.47","avg":"25.82"},{"id":"pip-tools 7.4.1","max":"27.64","min":"26.44","avg":"27.17"},{"id":"pipenv 2024.2.0","max":"22.05","min":"21.01","avg":"21.56"},{"id":"poetry 1.8.4","max":"6.2","min":"5.96","avg":"6.04"},{"id":"uv 0.4.27","max":"0.3","min":"0.26","avg":"0.28"}],"label":"warm"}]},"update":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"63.33","min":"61.72","avg":"62.51"},{"id":"pip-tools 7.4.1","max":"16.4","min":"13.98","avg":"15.19"},{"id":"pipenv 2024.2.0","max":"71.88","min":"67.69","avg":"70.46"},{"id":"poetry 1.8.4","max":"18.8","min":"15.67","avg":"17.42"},{"id":"uv 0.4.27","max":"1.73","min":"1.67","avg":"1.7"}],"label":"cold"},{"data":[{"id":"pdm 2.19.3","max":"57.44","min":"56.56","avg":"56.89"},{"id":"pip-tools 7.4.1","max":"13.12","min":"12.14","avg":"12.86"},{"id":"pipenv 2024.2.0","max":"66.53","min":"62.32","avg":"64.52"},{"id":"poetry 1.8.4","max":"8.67","min":"7.89","avg":"8.25"},{"id":"uv 0.4.27","max":"0.29","min":"0.26","avg":"0.28"}],"label":"warm"}]},"add-package":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"33.56","min":"32.01","avg":"32.6"},{"id":"pip-tools 7.4.1","max":"14.72","min":"13.17","avg":"13.97"},{"id":"pipenv 2024.2.0","max":"75.53","min":"72.25","avg":"73.54"},{"id":"poetry 1.8.4","max":"3.63","min":"3.14","avg":"3.36"},{"id":"uv 0.4.27","max":"0.35","min":"0.22","avg":"0.3"}]}]},"tooling":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"15.36","min":"11.71","avg":"12.74"},{"id":"pip-tools 7.4.1","max":"1.59","min":"0.99","avg":"1.27"},{"id":"pipenv 2024.2.0","max":"4.38","min":"3.43","avg":"3.76"},{"id":"poetry 1.8.4","max":"7.82","min":"6.07","avg":"6.96"},{"id":"uv 0.4.27","max":"1.18","min":"1.06","avg":"1.13"}]}]}}');const i="undefined"==typeof window?function(t){return t()}:window.requestAnimationFrame;function s(t,e,s){const n=s||(t=>Array.prototype.slice.call(t));let o=!1,a=[];return function(...s){a=n(s),o||(o=!0,i.call(window,(()=>{o=!1,t.apply(e,a)})))}}function n(t,e){let i;return function(...s){return e?(clearTimeout(i),i=setTimeout(t,e,s)):t.apply(this,s),e}}const o=t=>"start"===t?"left":"end"===t?"right":"center",a=(t,e,i)=>"start"===t?e:"end"===t?i:(e+i)/2,r=(t,e,i,s)=>t===(s?"left":"right")?i:"center"===t?(e+i)/2:e;function l(){}const h=function(){let t=0;return function(){return t++}}();function c(t){return null==t}function d(t){if(Array.isArray&&Array.isArray(t))return!0;const e=Object.prototype.toString.call(t);return"[object"===e.slice(0,7)&&"Array]"===e.slice(-6)}function u(t){return null!==t&&"[object Object]"===Object.prototype.toString.call(t)}const f=t=>("number"==typeof t||t instanceof Number)&&isFinite(+t);function g(t,e){return f(t)?t:e}function p(t,e){return void 0===t?e:t}const m=(t,e)=>"string"==typeof t&&t.endsWith("%")?parseFloat(t)/100*e:+t;function x(t,e,i){if(t&&"function"==typeof t.call)return t.apply(i,e)}function b(t,e,i,s){let n,o,a;if(d(t))if(o=t.length,s)for(n=o-1;n>=0;n--)e.call(i,t[n],n);else for(n=0;ni;)t=t[e.slice(i,s)],i=s+1,s=P(e,i);return t}function C(t){return t.charAt(0).toUpperCase()+t.slice(1)}const O=t=>void 0!==t,A=t=>"function"==typeof t,T=(t,e)=>{if(t.size!==e.size)return!1;for(const i of t)if(!e.has(i))return!1;return!0};function R(t){return"mouseup"===t.type||"click"===t.type||"contextmenu"===t.type}const L=Math.PI,E=2*L,I=E+L,z=Number.POSITIVE_INFINITY,F=L/180,W=L/2,V=L/4,j=2*L/3,B=Math.log10,N=Math.sign;function H(t){const e=Math.round(t);t=X(t,e,t/1e3)?e:t;const i=Math.pow(10,Math.floor(B(t))),s=t/i;return(s<=1?1:s<=2?2:s<=5?5:10)*i}function $(t){const e=[],i=Math.sqrt(t);let s;for(s=1;st-e)).pop(),e}function Y(t){return!isNaN(parseFloat(t))&&isFinite(t)}function X(t,e,i){return Math.abs(t-e)=t}function q(t,e,i){let s,n,o;for(s=0,n=t.length;sl&&h=Math.min(e,i)-s&&t<=Math.max(e,i)+s}const ot=t=>0===t||1===t,at=(t,e,i)=>-Math.pow(2,10*(t-=1))*Math.sin((t-e)*E/i),rt=(t,e,i)=>Math.pow(2,-10*t)*Math.sin((t-e)*E/i)+1,lt={linear:t=>t,easeInQuad:t=>t*t,easeOutQuad:t=>-t*(t-2),easeInOutQuad:t=>(t/=.5)<1?.5*t*t:-.5*(--t*(t-2)-1),easeInCubic:t=>t*t*t,easeOutCubic:t=>(t-=1)*t*t+1,easeInOutCubic:t=>(t/=.5)<1?.5*t*t*t:.5*((t-=2)*t*t+2),easeInQuart:t=>t*t*t*t,easeOutQuart:t=>-((t-=1)*t*t*t-1),easeInOutQuart:t=>(t/=.5)<1?.5*t*t*t*t:-.5*((t-=2)*t*t*t-2),easeInQuint:t=>t*t*t*t*t,easeOutQuint:t=>(t-=1)*t*t*t*t+1,easeInOutQuint:t=>(t/=.5)<1?.5*t*t*t*t*t:.5*((t-=2)*t*t*t*t+2),easeInSine:t=>1-Math.cos(t*W),easeOutSine:t=>Math.sin(t*W),easeInOutSine:t=>-.5*(Math.cos(L*t)-1),easeInExpo:t=>0===t?0:Math.pow(2,10*(t-1)),easeOutExpo:t=>1===t?1:1-Math.pow(2,-10*t),easeInOutExpo:t=>ot(t)?t:t<.5?.5*Math.pow(2,10*(2*t-1)):.5*(2-Math.pow(2,-10*(2*t-1))),easeInCirc:t=>t>=1?t:-(Math.sqrt(1-t*t)-1),easeOutCirc:t=>Math.sqrt(1-(t-=1)*t),easeInOutCirc:t=>(t/=.5)<1?-.5*(Math.sqrt(1-t*t)-1):.5*(Math.sqrt(1-(t-=2)*t)+1),easeInElastic:t=>ot(t)?t:at(t,.075,.3),easeOutElastic:t=>ot(t)?t:rt(t,.075,.3),easeInOutElastic(t){const e=.1125;return ot(t)?t:t<.5?.5*at(2*t,e,.45):.5+.5*rt(2*t-1,e,.45)},easeInBack(t){const e=1.70158;return t*t*((e+1)*t-e)},easeOutBack(t){const e=1.70158;return(t-=1)*t*((e+1)*t+e)+1},easeInOutBack(t){let e=1.70158;return(t/=.5)<1?t*t*((1+(e*=1.525))*t-e)*.5:.5*((t-=2)*t*((1+(e*=1.525))*t+e)+2)},easeInBounce:t=>1-lt.easeOutBounce(1-t),easeOutBounce(t){const e=7.5625,i=2.75;return t<1/i?e*t*t:t<2/i?e*(t-=1.5/i)*t+.75:t<2.5/i?e*(t-=2.25/i)*t+.9375:e*(t-=2.625/i)*t+.984375},easeInOutBounce:t=>t<.5?.5*lt.easeInBounce(2*t):.5*lt.easeOutBounce(2*t-1)+.5}; +function t(t){return t&&t.__esModule?t.default:t}var e;e=JSON.parse('{"lock":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"72.39","min":"70.1","avg":"71.4"},{"id":"pip-tools 7.4.1","max":"32.59","min":"28.22","avg":"30.78"},{"id":"pipenv 2024.2.0","max":"46.71","min":"43.69","avg":"45.34"},{"id":"poetry 1.8.4","max":"18.62","min":"15.51","avg":"17.31"},{"id":"uv 0.4.27","max":"2.15","min":"1.66","avg":"1.94"}],"label":"cold"},{"data":[{"id":"pdm 2.19.3","max":"64.81","min":"64.33","avg":"64.62"},{"id":"pip-tools 7.4.1","max":"24.61","min":"22.82","avg":"23.53"},{"id":"pipenv 2024.2.0","max":"41.41","min":"38.78","avg":"39.9"},{"id":"poetry 1.8.4","max":"8.02","min":"7.33","avg":"7.7"},{"id":"uv 0.4.27","max":"0.12","min":"0.11","avg":"0.12"}],"label":"warm"}]},"install":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"43.72","min":"39.6","avg":"41.29"},{"id":"pip-tools 7.4.1","max":"53.85","min":"46.84","avg":"49.59"},{"id":"pipenv 2024.2.0","max":"42.63","min":"40.7","avg":"41.79"},{"id":"poetry 1.8.4","max":"27.39","min":"25.9","avg":"26.66"},{"id":"uv 0.4.27","max":"20.88","min":"18.69","avg":"19.53"}],"label":"cold"},{"data":[{"id":"pdm 2.19.3","max":"25.91","min":"25.47","avg":"25.75"},{"id":"pip-tools 7.4.1","max":"27.64","min":"26.73","avg":"27.24"},{"id":"pipenv 2024.2.0","max":"22.05","min":"20.7","avg":"21.49"},{"id":"poetry 1.8.4","max":"6.2","min":"5.96","avg":"6.05"},{"id":"uv 0.4.27","max":"0.3","min":"0.26","avg":"0.27"}],"label":"warm"}]},"update":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"63.89","min":"61.72","avg":"62.65"},{"id":"pip-tools 7.4.1","max":"18.1","min":"14.86","avg":"16.22"},{"id":"pipenv 2024.2.0","max":"71.88","min":"66.43","avg":"69.41"},{"id":"poetry 1.8.4","max":"18.99","min":"15.67","avg":"17.47"},{"id":"uv 0.4.27","max":"1.73","min":"1.62","avg":"1.68"}],"label":"cold"},{"data":[{"id":"pdm 2.19.3","max":"56.93","min":"56.15","avg":"56.56"},{"id":"pip-tools 7.4.1","max":"13.12","min":"12.64","avg":"12.99"},{"id":"pipenv 2024.2.0","max":"66.53","min":"61.23","avg":"64.24"},{"id":"poetry 1.8.4","max":"8.67","min":"7.89","avg":"8.27"},{"id":"uv 0.4.27","max":"0.29","min":"0.26","avg":"0.28"}],"label":"warm"}]},"add-package":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"32.56","min":"32.01","avg":"32.34"},{"id":"pip-tools 7.4.1","max":"14.72","min":"13.78","avg":"14.12"},{"id":"pipenv 2024.2.0","max":"75.53","min":"68.96","avg":"72.69"},{"id":"poetry 1.8.4","max":"3.65","min":"3.14","avg":"3.4"},{"id":"uv 0.4.27","max":"0.35","min":"0.22","avg":"0.31"}]}]},"tooling":{"labels":[],"datasets":[{"data":[{"id":"pdm 2.19.3","max":"15.36","min":"11.9","avg":"12.84"},{"id":"pip-tools 7.4.1","max":"1.59","min":"0.99","avg":"1.31"},{"id":"pipenv 2024.2.0","max":"4.38","min":"3.41","avg":"3.71"},{"id":"poetry 1.8.4","max":"7.87","min":"6.07","avg":"7.23"},{"id":"uv 0.4.27","max":"1.21","min":"1.06","avg":"1.15"}]}]}}');const i="undefined"==typeof window?function(t){return t()}:window.requestAnimationFrame;function s(t,e,s){const n=s||(t=>Array.prototype.slice.call(t));let o=!1,a=[];return function(...s){a=n(s),o||(o=!0,i.call(window,(()=>{o=!1,t.apply(e,a)})))}}function n(t,e){let i;return function(...s){return e?(clearTimeout(i),i=setTimeout(t,e,s)):t.apply(this,s),e}}const o=t=>"start"===t?"left":"end"===t?"right":"center",a=(t,e,i)=>"start"===t?e:"end"===t?i:(e+i)/2,r=(t,e,i,s)=>t===(s?"left":"right")?i:"center"===t?(e+i)/2:e;function l(){}const h=function(){let t=0;return function(){return t++}}();function c(t){return null==t}function d(t){if(Array.isArray&&Array.isArray(t))return!0;const e=Object.prototype.toString.call(t);return"[object"===e.slice(0,7)&&"Array]"===e.slice(-6)}function u(t){return null!==t&&"[object Object]"===Object.prototype.toString.call(t)}const f=t=>("number"==typeof t||t instanceof Number)&&isFinite(+t);function g(t,e){return f(t)?t:e}function p(t,e){return void 0===t?e:t}const m=(t,e)=>"string"==typeof t&&t.endsWith("%")?parseFloat(t)/100*e:+t;function x(t,e,i){if(t&&"function"==typeof t.call)return t.apply(i,e)}function b(t,e,i,s){let n,o,a;if(d(t))if(o=t.length,s)for(n=o-1;n>=0;n--)e.call(i,t[n],n);else for(n=0;ni;)t=t[e.slice(i,s)],i=s+1,s=P(e,i);return t}function C(t){return t.charAt(0).toUpperCase()+t.slice(1)}const O=t=>void 0!==t,A=t=>"function"==typeof t,T=(t,e)=>{if(t.size!==e.size)return!1;for(const i of t)if(!e.has(i))return!1;return!0};function R(t){return"mouseup"===t.type||"click"===t.type||"contextmenu"===t.type}const L=Math.PI,E=2*L,I=E+L,z=Number.POSITIVE_INFINITY,F=L/180,W=L/2,V=L/4,j=2*L/3,B=Math.log10,N=Math.sign;function H(t){const e=Math.round(t);t=X(t,e,t/1e3)?e:t;const i=Math.pow(10,Math.floor(B(t))),s=t/i;return(s<=1?1:s<=2?2:s<=5?5:10)*i}function $(t){const e=[],i=Math.sqrt(t);let s;for(s=1;st-e)).pop(),e}function Y(t){return!isNaN(parseFloat(t))&&isFinite(t)}function X(t,e,i){return Math.abs(t-e)=t}function q(t,e,i){let s,n,o;for(s=0,n=t.length;sl&&h=Math.min(e,i)-s&&t<=Math.max(e,i)+s}const ot=t=>0===t||1===t,at=(t,e,i)=>-Math.pow(2,10*(t-=1))*Math.sin((t-e)*E/i),rt=(t,e,i)=>Math.pow(2,-10*t)*Math.sin((t-e)*E/i)+1,lt={linear:t=>t,easeInQuad:t=>t*t,easeOutQuad:t=>-t*(t-2),easeInOutQuad:t=>(t/=.5)<1?.5*t*t:-.5*(--t*(t-2)-1),easeInCubic:t=>t*t*t,easeOutCubic:t=>(t-=1)*t*t+1,easeInOutCubic:t=>(t/=.5)<1?.5*t*t*t:.5*((t-=2)*t*t+2),easeInQuart:t=>t*t*t*t,easeOutQuart:t=>-((t-=1)*t*t*t-1),easeInOutQuart:t=>(t/=.5)<1?.5*t*t*t*t:-.5*((t-=2)*t*t*t-2),easeInQuint:t=>t*t*t*t*t,easeOutQuint:t=>(t-=1)*t*t*t*t+1,easeInOutQuint:t=>(t/=.5)<1?.5*t*t*t*t*t:.5*((t-=2)*t*t*t*t+2),easeInSine:t=>1-Math.cos(t*W),easeOutSine:t=>Math.sin(t*W),easeInOutSine:t=>-.5*(Math.cos(L*t)-1),easeInExpo:t=>0===t?0:Math.pow(2,10*(t-1)),easeOutExpo:t=>1===t?1:1-Math.pow(2,-10*t),easeInOutExpo:t=>ot(t)?t:t<.5?.5*Math.pow(2,10*(2*t-1)):.5*(2-Math.pow(2,-10*(2*t-1))),easeInCirc:t=>t>=1?t:-(Math.sqrt(1-t*t)-1),easeOutCirc:t=>Math.sqrt(1-(t-=1)*t),easeInOutCirc:t=>(t/=.5)<1?-.5*(Math.sqrt(1-t*t)-1):.5*(Math.sqrt(1-(t-=2)*t)+1),easeInElastic:t=>ot(t)?t:at(t,.075,.3),easeOutElastic:t=>ot(t)?t:rt(t,.075,.3),easeInOutElastic(t){const e=.1125;return ot(t)?t:t<.5?.5*at(2*t,e,.45):.5+.5*rt(2*t-1,e,.45)},easeInBack(t){const e=1.70158;return t*t*((e+1)*t-e)},easeOutBack(t){const e=1.70158;return(t-=1)*t*((e+1)*t+e)+1},easeInOutBack(t){let e=1.70158;return(t/=.5)<1?t*t*((1+(e*=1.525))*t-e)*.5:.5*((t-=2)*t*((1+(e*=1.525))*t+e)+2)},easeInBounce:t=>1-lt.easeOutBounce(1-t),easeOutBounce(t){const e=7.5625,i=2.75;return t<1/i?e*t*t:t<2/i?e*(t-=1.5/i)*t+.75:t<2.5/i?e*(t-=2.25/i)*t+.9375:e*(t-=2.625/i)*t+.984375},easeInOutBounce:t=>t<.5?.5*lt.easeInBounce(2*t):.5*lt.easeOutBounce(2*t-1)+.5}; /*! * @kurkle/color v0.2.1 * https://github.com/kurkle/color#readme @@ -6,4 +6,4 @@ function t(t){return t&&t.__esModule?t.default:t}var e;e=JSON.parse('{"lock":{"l * Released under the MIT License */ function ht(t){return t+.5|0}const ct=(t,e,i)=>Math.max(Math.min(t,i),e);function dt(t){return ct(ht(2.55*t),0,255)}function ut(t){return ct(ht(255*t),0,255)}function ft(t){return ct(ht(t/2.55)/100,0,1)}function gt(t){return ct(ht(100*t),0,100)}const pt={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15},mt=[..."0123456789ABCDEF"],xt=t=>mt[15&t],bt=t=>mt[(240&t)>>4]+mt[15&t],yt=t=>(240&t)>>4==(15&t);function _t(t){var e=(t=>yt(t.r)&&yt(t.g)&&yt(t.b)&&yt(t.a))(t)?xt:bt;return t?"#"+e(t.r)+e(t.g)+e(t.b)+((t,e)=>t<255?e(t):"")(t.a,e):void 0}const vt=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function wt(t,e,i){const s=e*Math.min(i,1-i),n=(e,n=(e+t/30)%12)=>i-s*Math.max(Math.min(n-3,9-n,1),-1);return[n(0),n(8),n(4)]}function Mt(t,e,i){const s=(s,n=(s+t/60)%6)=>i-i*e*Math.max(Math.min(n,4-n,1),0);return[s(5),s(3),s(1)]}function kt(t,e,i){const s=wt(t,1,.5);let n;for(e+i>1&&(n=1/(e+i),e*=n,i*=n),n=0;n<3;n++)s[n]*=1-e-i,s[n]+=e;return s}function St(t){const e=t.r/255,i=t.g/255,s=t.b/255,n=Math.max(e,i,s),o=Math.min(e,i,s),a=(n+o)/2;let r,l,h;return n!==o&&(h=n-o,l=a>.5?h/(2-n-o):h/(n+o),r=function(t,e,i,s,n){return t===n?(e-i)/s+(e>16&255,o>>8&255,255&o]}return t}(),Rt.transparent=[0,0,0,0]);const e=Rt[t.toLowerCase()];return e&&{r:e[0],g:e[1],b:e[2],a:4===e.length?e[3]:255}}const Et=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;const It=t=>t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055,zt=t=>t<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4);function Ft(t,e,i){if(t){let s=St(t);s[e]=Math.max(0,Math.min(s[e]+s[e]*i,0===e?360:1)),s=Dt(s),t.r=s[0],t.g=s[1],t.b=s[2]}}function Wt(t,e){return t?Object.assign(e||{},t):t}function Vt(t){var e={r:0,g:0,b:0,a:255};return Array.isArray(t)?t.length>=3&&(e={r:t[0],g:t[1],b:t[2],a:255},t.length>3&&(e.a=ut(t[3]))):(e=Wt(t,{r:0,g:0,b:0,a:1})).a=ut(e.a),e}function jt(t){return"r"===t.charAt(0)?function(t){const e=Et.exec(t);let i,s,n,o=255;if(e){if(e[7]!==i){const t=+e[7];o=e[8]?dt(t):ct(255*t,0,255)}return i=+e[1],s=+e[3],n=+e[5],i=255&(e[2]?dt(i):ct(i,0,255)),s=255&(e[4]?dt(s):ct(s,0,255)),n=255&(e[6]?dt(n):ct(n,0,255)),{r:i,g:s,b:n,a:o}}}(t):Ot(t)}class Bt{constructor(t){if(t instanceof Bt)return t;const e=typeof t;let i;var s,n,o;"object"===e?i=Vt(t):"string"===e&&(o=(s=t).length,"#"===s[0]&&(4===o||5===o?n={r:255&17*pt[s[1]],g:255&17*pt[s[2]],b:255&17*pt[s[3]],a:5===o?17*pt[s[4]]:255}:7!==o&&9!==o||(n={r:pt[s[1]]<<4|pt[s[2]],g:pt[s[3]]<<4|pt[s[4]],b:pt[s[5]]<<4|pt[s[6]],a:9===o?pt[s[7]]<<4|pt[s[8]]:255})),i=n||Lt(t)||jt(t)),this._rgb=i,this._valid=!!i}get valid(){return this._valid}get rgb(){var t=Wt(this._rgb);return t&&(t.a=ft(t.a)),t}set rgb(t){this._rgb=Vt(t)}rgbString(){return this._valid?(t=this._rgb)&&(t.a<255?`rgba(${t.r}, ${t.g}, ${t.b}, ${ft(t.a)})`:`rgb(${t.r}, ${t.g}, ${t.b})`):void 0;var t}hexString(){return this._valid?_t(this._rgb):void 0}hslString(){return this._valid?function(t){if(!t)return;const e=St(t),i=e[0],s=gt(e[1]),n=gt(e[2]);return t.a<255?`hsla(${i}, ${s}%, ${n}%, ${ft(t.a)})`:`hsl(${i}, ${s}%, ${n}%)`}(this._rgb):void 0}mix(t,e){if(t){const i=this.rgb,s=t.rgb;let n;const o=e===n?.5:e,a=2*o-1,r=i.a-s.a,l=((a*r==-1?a:(a+r)/(1+a*r))+1)/2;n=1-l,i.r=255&l*i.r+n*s.r+.5,i.g=255&l*i.g+n*s.g+.5,i.b=255&l*i.b+n*s.b+.5,i.a=o*i.a+(1-o)*s.a,this.rgb=i}return this}interpolate(t,e){return t&&(this._rgb=function(t,e,i){const s=zt(ft(t.r)),n=zt(ft(t.g)),o=zt(ft(t.b));return{r:ut(It(s+i*(zt(ft(e.r))-s))),g:ut(It(n+i*(zt(ft(e.g))-n))),b:ut(It(o+i*(zt(ft(e.b))-o))),a:t.a+i*(e.a-t.a)}}(this._rgb,t._rgb,e)),this}clone(){return new Bt(this.rgb)}alpha(t){return this._rgb.a=ut(t),this}clearer(t){return this._rgb.a*=1-t,this}greyscale(){const t=this._rgb,e=ht(.3*t.r+.59*t.g+.11*t.b);return t.r=t.g=t.b=e,this}opaquer(t){return this._rgb.a*=1+t,this}negate(){const t=this._rgb;return t.r=255-t.r,t.g=255-t.g,t.b=255-t.b,this}lighten(t){return Ft(this._rgb,2,t),this}darken(t){return Ft(this._rgb,2,-t),this}saturate(t){return Ft(this._rgb,1,t),this}desaturate(t){return Ft(this._rgb,1,-t),this}rotate(t){return function(t,e){var i=St(t);i[0]=Ct(i[0]+e),i=Dt(i),t.r=i[0],t.g=i[1],t.b=i[2]}(this._rgb,t),this}}function Nt(t){return new Bt(t)}function Ht(t){if(t&&"object"==typeof t){const e=t.toString();return"[object CanvasPattern]"===e||"[object CanvasGradient]"===e}return!1}function $t(t){return Ht(t)?t:Nt(t)}function Yt(t){return Ht(t)?t:Nt(t).saturate(.5).darken(.1).hexString()}const Xt=Object.create(null),Ut=Object.create(null);function qt(t,e){if(!e)return t;const i=e.split(".");for(let e=0,s=i.length;et.chart.platform.getDevicePixelRatio(),this.elements={},this.events=["mousemove","mouseout","click","touchstart","touchmove"],this.font={family:"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",size:12,style:"normal",lineHeight:1.2,weight:null},this.hover={},this.hoverBackgroundColor=(t,e)=>Yt(e.backgroundColor),this.hoverBorderColor=(t,e)=>Yt(e.borderColor),this.hoverColor=(t,e)=>Yt(e.color),this.indexAxis="x",this.interaction={mode:"nearest",intersect:!0,includeInvisible:!1},this.maintainAspectRatio=!0,this.onHover=null,this.onClick=null,this.parsing=!0,this.plugins={},this.responsive=!0,this.scale=void 0,this.scales={},this.showLine=!0,this.drawActiveElementsOnTop=!0,this.describe(t)}set(t,e){return Kt(this,t,e)}get(t){return qt(this,t)}describe(t,e){return Kt(Ut,t,e)}override(t,e){return Kt(Xt,t,e)}route(t,e,i,s){const n=qt(this,t),o=qt(this,i),a="_"+e;Object.defineProperties(n,{[a]:{value:n[e],writable:!0},[e]:{enumerable:!0,get(){const t=this[a],e=o[s];return u(t)?Object.assign({},e,t):p(t,e)},set(t){this[a]=t}}})}}({_scriptable:t=>!t.startsWith("on"),_indexable:t=>"events"!==t,hover:{_fallback:"interaction"},interaction:{_scriptable:!1,_indexable:!1}});function Gt(t,e,i,s,n){let o=e[n];return o||(o=e[n]=t.measureText(n).width,i.push(n)),o>s&&(s=o),s}function Zt(t,e,i,s){let n=(s=s||{}).data=s.data||{},o=s.garbageCollect=s.garbageCollect||[];s.font!==e&&(n=s.data={},o=s.garbageCollect=[],s.font=e),t.save(),t.font=e;let a=0;const r=i.length;let l,h,c,u,f;for(l=0;li.length){for(l=0;l0&&t.stroke()}}function ie(t,e,i){return i=i||.5,!e||t&&t.x>e.left-i&&t.xe.top-i&&t.y0&&""!==o.strokeColor;let l,h;for(t.save(),t.font=n.string,function(t,e){e.translation&&t.translate(e.translation[0],e.translation[1]);c(e.rotation)||t.rotate(e.rotation);e.color&&(t.fillStyle=e.color);e.textAlign&&(t.textAlign=e.textAlign);e.textBaseline&&(t.textBaseline=e.textBaseline)}(t,o),l=0;lp(t[i],t[e[i]]):e=>t[e]:()=>t;for(const t of n)i[t]=+o(t)||0;return i}function ge(t){return fe(t,{top:"y",right:"x",bottom:"y",left:"x"})}function pe(t){return fe(t,["topLeft","topRight","bottomLeft","bottomRight"])}function me(t){const e=ge(t);return e.width=e.left+e.right,e.height=e.top+e.bottom,e}function xe(t,e){t=t||{},e=e||Jt.font;let i=p(t.size,e.size);"string"==typeof i&&(i=parseInt(i,10));let s=p(t.style,e.style);s&&!(""+s).match(de)&&(console.warn('Invalid font style specified: "'+s+'"'),s="");const n={family:p(t.family,e.family),lineHeight:ue(p(t.lineHeight,e.lineHeight),i),size:i,style:s,weight:p(t.weight,e.weight),string:""};return n.string=function(t){return!t||c(t.size)||c(t.family)?null:(t.style?t.style+" ":"")+(t.weight?t.weight+" ":"")+t.size+"px "+t.family}(n),n}function be(t,e,i,s){let n,o,a,r=!0;for(n=0,o=t.length;ni&&0===t?0:t+e;return{min:a(s,-Math.abs(o)),max:a(n,o)}}function _e(t,e){return Object.assign(Object.create(t),e)}function ve(t,e,i){i=i||(i=>t[i]1;)s=o+n>>1,i(s)?o=s:n=s;return{lo:o,hi:n}}const we=(t,e,i)=>ve(t,i,(s=>t[s][e]ve(t,i,(s=>t[s][e]>=i));function ke(t,e,i){let s=0,n=t.length;for(;ss&&t[n-1]>i;)n--;return s>0||n0||(Se.forEach((e=>{delete t[e]})),delete t._chartjs)}function De(t){const e=new Set;let i,s;for(i=0,s=t.length;it[0])){O(s)||(s=Ve("_fallback",t));const o={[Symbol.toStringTag]:"Object",_cacheable:!0,_scopes:t,_rootScopes:i,_fallback:s,_getTarget:n,override:n=>Ce([n,...t],e,i,s)};return new Proxy(o,{deleteProperty:(e,i)=>(delete e[i],delete e._keys,delete t[0][i],!0),get:(i,s)=>Le(i,s,(()=>function(t,e,i,s){let n;for(const o of e)if(n=Ve(Te(o,t),i),O(n))return Re(t,n)?Fe(i,s,t,n):n}(s,e,t,i))),getOwnPropertyDescriptor:(t,e)=>Reflect.getOwnPropertyDescriptor(t._scopes[0],e),getPrototypeOf:()=>Reflect.getPrototypeOf(t[0]),has:(t,e)=>je(t).includes(e),ownKeys:t=>je(t),set(t,e,i){const s=t._storage||(t._storage=n());return t[e]=s[e]=i,delete t._keys,!0}})}function Oe(t,e,i,s){const n={_cacheable:!1,_proxy:t,_context:e,_subProxy:i,_stack:new Set,_descriptors:Ae(t,s),setContext:e=>Oe(t,e,i,s),override:n=>Oe(t.override(n),e,i,s)};return new Proxy(n,{deleteProperty:(e,i)=>(delete e[i],delete t[i],!0),get:(t,e,i)=>Le(t,e,(()=>function(t,e,i){const{_proxy:s,_context:n,_subProxy:o,_descriptors:a}=t;let r=s[e];A(r)&&a.isScriptable(e)&&(r=function(t,e,i,s){const{_proxy:n,_context:o,_subProxy:a,_stack:r}=i;if(r.has(t))throw new Error("Recursion detected: "+Array.from(r).join("->")+"->"+t);r.add(t),e=e(o,a||s),r.delete(t),Re(t,e)&&(e=Fe(n._scopes,n,t,e));return e}(e,r,t,i));d(r)&&r.length&&(r=function(t,e,i,s){const{_proxy:n,_context:o,_subProxy:a,_descriptors:r}=i;if(O(o.index)&&s(t))e=e[o.index%e.length];else if(u(e[0])){const i=e,s=n._scopes.filter((t=>t!==i));e=[];for(const l of i){const i=Fe(s,n,t,l);e.push(Oe(i,o,a&&a[t],r))}}return e}(e,r,t,a.isIndexable));Re(e,r)&&(r=Oe(r,n,o&&o[e],a));return r}(t,e,i))),getOwnPropertyDescriptor:(e,i)=>e._descriptors.allKeys?Reflect.has(t,i)?{enumerable:!0,configurable:!0}:void 0:Reflect.getOwnPropertyDescriptor(t,i),getPrototypeOf:()=>Reflect.getPrototypeOf(t),has:(e,i)=>Reflect.has(t,i),ownKeys:()=>Reflect.ownKeys(t),set:(e,i,s)=>(t[i]=s,delete e[i],!0)})}function Ae(t,e={scriptable:!0,indexable:!0}){const{_scriptable:i=e.scriptable,_indexable:s=e.indexable,_allKeys:n=e.allKeys}=t;return{allKeys:n,scriptable:i,indexable:s,isScriptable:A(i)?i:()=>i,isIndexable:A(s)?s:()=>s}}const Te=(t,e)=>t?t+C(e):e,Re=(t,e)=>u(e)&&"adapters"!==t&&(null===Object.getPrototypeOf(e)||e.constructor===Object);function Le(t,e,i){if(Object.prototype.hasOwnProperty.call(t,e))return t[e];const s=i();return t[e]=s,s}function Ee(t,e,i){return A(t)?t(e,i):t}const Ie=(t,e)=>!0===t?e:"string"==typeof t?D(e,t):void 0;function ze(t,e,i,s,n){for(const o of e){const e=Ie(i,o);if(e){t.add(e);const o=Ee(e._fallback,i,n);if(O(o)&&o!==i&&o!==s)return o}else if(!1===e&&O(s)&&i!==s)return null}return!1}function Fe(t,e,i,s){const n=e._rootScopes,o=Ee(e._fallback,i,s),a=[...t,...n],r=new Set;r.add(s);let l=We(r,a,i,o||i,s);return null!==l&&((!O(o)||o===i||(l=We(r,a,o,l,s),null!==l))&&Ce(Array.from(r),[""],n,o,(()=>function(t,e,i){const s=t._getTarget();e in s||(s[e]={});const n=s[e];return d(n)&&u(i)?i:n}(e,i,s))))}function We(t,e,i,s,n){for(;i;)i=ze(t,e,i,s,n);return i}function Ve(t,e){for(const i of e){if(!i)continue;const e=i[t];if(O(e))return e}}function je(t){let e=t._keys;return e||(e=t._keys=function(t){const e=new Set;for(const i of t)for(const t of Object.keys(i).filter((t=>!t.startsWith("_"))))e.add(t);return Array.from(e)}(t._scopes)),e}function Be(t,e,i,s){const{iScale:n}=t,{key:o="r"}=this._parsing,a=new Array(s);let r,l,h,c;for(r=0,l=s;re"x"===t?"y":"x";function Ye(t,e,i,s){const n=t.skip?e:t,o=e,a=i.skip?e:i,r=Q(o,n),l=Q(a,o);let h=r/(r+l),c=l/(r+l);h=isNaN(h)?0:h,c=isNaN(c)?0:c;const d=s*h,u=s*c;return{previous:{x:o.x-d*(a.x-n.x),y:o.y-d*(a.y-n.y)},next:{x:o.x+u*(a.x-n.x),y:o.y+u*(a.y-n.y)}}}function Xe(t,e="x"){const i=$e(e),s=t.length,n=Array(s).fill(0),o=Array(s);let a,r,l,h=He(t,0);for(a=0;a!t.skip))),"monotone"===e.cubicInterpolationMode)Xe(t,n);else{let i=s?t[t.length-1]:t[0];for(o=0,a=t.length;owindow.getComputedStyle(t,null);const Qe=["top","right","bottom","left"];function ti(t,e,i){const s={};i=i?"-"+i:"";for(let n=0;n<4;n++){const o=Qe[n];s[o]=parseFloat(t[e+"-"+o+i])||0}return s.width=s.left+s.right,s.height=s.top+s.bottom,s}function ei(t,e){if("native"in t)return t;const{canvas:i,currentDevicePixelRatio:s}=e,n=Ze(i),o="border-box"===n.boxSizing,a=ti(n,"padding"),r=ti(n,"border","width"),{x:l,y:h,box:c}=function(t,e){const i=t.touches,s=i&&i.length?i[0]:t,{offsetX:n,offsetY:o}=s;let a,r,l=!1;if(((t,e,i)=>(t>0||e>0)&&(!i||!i.shadowRoot))(n,o,t.target))a=n,r=o;else{const t=e.getBoundingClientRect();a=s.clientX-t.left,r=s.clientY-t.top,l=!0}return{x:a,y:r,box:l}}(t,i),d=a.left+(c&&r.left),u=a.top+(c&&r.top);let{width:f,height:g}=e;return o&&(f-=a.width+r.width,g-=a.height+r.height),{x:Math.round((l-d)/f*i.width/s),y:Math.round((h-u)/g*i.height/s)}}const ii=t=>Math.round(10*t)/10;function si(t,e,i,s){const n=Ze(t),o=ti(n,"margin"),a=Ge(n.maxWidth,t,"clientWidth")||z,r=Ge(n.maxHeight,t,"clientHeight")||z,l=function(t,e,i){let s,n;if(void 0===e||void 0===i){const o=Je(t);if(o){const t=o.getBoundingClientRect(),a=Ze(o),r=ti(a,"border","width"),l=ti(a,"padding");e=t.width-l.width-r.width,i=t.height-l.height-r.height,s=Ge(a.maxWidth,o,"clientWidth"),n=Ge(a.maxHeight,o,"clientHeight")}else e=t.clientWidth,i=t.clientHeight}return{width:e,height:i,maxWidth:s||z,maxHeight:n||z}}(t,e,i);let{width:h,height:c}=l;if("content-box"===n.boxSizing){const t=ti(n,"border","width"),e=ti(n,"padding");h-=e.width+t.width,c-=e.height+t.height}return h=Math.max(0,h-o.width),c=Math.max(0,s?Math.floor(h/s):c-o.height),h=ii(Math.min(h,a,l.maxWidth)),c=ii(Math.min(c,r,l.maxHeight)),h&&!c&&(c=ii(h/2)),{width:h,height:c}}function ni(t,e,i){const s=e||1,n=Math.floor(t.height*s),o=Math.floor(t.width*s);t.height=n/s,t.width=o/s;const a=t.canvas;return a.style&&(i||!a.style.height&&!a.style.width)&&(a.style.height=`${t.height}px`,a.style.width=`${t.width}px`),(t.currentDevicePixelRatio!==s||a.height!==n||a.width!==o)&&(t.currentDevicePixelRatio=s,a.height=n,a.width=o,t.ctx.setTransform(s,0,0,s,0,0),!0)}const oi=function(){let t=!1;try{const e={get passive(){return t=!0,!1}};window.addEventListener("test",null,e),window.removeEventListener("test",null,e)}catch(t){}return t}();function ai(t,e){const i=function(t,e){return Ze(t).getPropertyValue(e)}(t,e),s=i&&i.match(/^(\d+)(\.\d+)?px$/);return s?+s[1]:void 0}function ri(t,e,i,s){return{x:t.x+i*(e.x-t.x),y:t.y+i*(e.y-t.y)}}function li(t,e,i,s){return{x:t.x+i*(e.x-t.x),y:"middle"===s?i<.5?t.y:e.y:"after"===s?i<1?t.y:e.y:i>0?e.y:t.y}}function hi(t,e,i,s){const n={x:t.cp2x,y:t.cp2y},o={x:e.cp1x,y:e.cp1y},a=ri(t,n,i),r=ri(n,o,i),l=ri(o,e,i),h=ri(a,r,i),c=ri(r,l,i);return ri(h,c,i)}const ci=new Map;function di(t,e,i){return function(t,e){e=e||{};const i=t+JSON.stringify(e);let s=ci.get(i);return s||(s=new Intl.NumberFormat(t,e),ci.set(i,s)),s}(e,i).format(t)}function ui(t,e,i){return t?function(t,e){return{x:i=>t+t+e-i,setWidth(t){e=t},textAlign:t=>"center"===t?t:"right"===t?"left":"right",xPlus:(t,e)=>t-e,leftForLtr:(t,e)=>t-e}}(e,i):{x:t=>t,setWidth(t){},textAlign:t=>t,xPlus:(t,e)=>t+e,leftForLtr:(t,e)=>t}}function fi(t,e){let i,s;"ltr"!==e&&"rtl"!==e||(i=t.canvas.style,s=[i.getPropertyValue("direction"),i.getPropertyPriority("direction")],i.setProperty("direction",e,"important"),t.prevTextDirection=s)}function gi(t,e){void 0!==e&&(delete t.prevTextDirection,t.canvas.style.setProperty("direction",e[0],e[1]))}function pi(t){return"angle"===t?{between:it,compare:tt,normalize:et}:{between:nt,compare:(t,e)=>t-e,normalize:t=>t}}function mi({start:t,end:e,count:i,loop:s,style:n}){return{start:t%i,end:e%i,loop:s&&(e-t+1)%i==0,style:n}}function xi(t,e,i){if(!i)return[t];const{property:s,start:n,end:o}=i,a=e.length,{compare:r,between:l,normalize:h}=pi(s),{start:c,end:d,loop:u,style:f}=function(t,e,i){const{property:s,start:n,end:o}=i,{between:a,normalize:r}=pi(s),l=e.length;let h,c,{start:d,end:u,loop:f}=t;if(f){for(d+=l,u+=l,h=0,c=l;hb||l(n,x,p)&&0!==r(n,x),v=()=>!b||0===r(o,p)||l(o,x,p);for(let t=c,i=c;t<=d;++t)m=e[t%a],m.skip||(p=h(m[s]),p!==x&&(b=l(p,n,o),null===y&&_()&&(y=0===r(p,n)?t:i),null!==y&&v()&&(g.push(mi({start:y,end:t,loop:u,count:a,style:f})),y=null),i=t,x=p));return null!==y&&g.push(mi({start:y,end:d,loop:u,count:a,style:f})),g}function bi(t,e){const i=[],s=t.segments;for(let n=0;nn&&t[o%e].skip;)o--;return o%=e,{start:n,end:o}}(i,n,o,s);if(!0===s)return _i(t,[{start:a,end:r,loop:o}],i,e);return _i(t,function(t,e,i,s){const n=t.length,o=[];let a,r=e,l=t[e];for(a=e+1;a<=i;++a){const i=t[a%n];i.skip||i.stop?l.skip||(s=!1,o.push({start:e%n,end:(a-1)%n,loop:s}),e=r=i.stop?a:null):(r=a,l.skip&&(e=a)),l=i}return null!==r&&o.push({start:e%n,end:r%n,loop:s}),o}(i,a,rs({chart:t,initial:e.initial,numSteps:o,currentStep:Math.min(i-e.start,o)})))}_refresh(){this._request||(this._running=!0,this._request=i.call(window,(()=>{this._update(),this._request=null,this._running&&this._refresh()})))}_update(t=Date.now()){let e=0;this._charts.forEach(((i,s)=>{if(!i.running||!i.items.length)return;const n=i.items;let o,a=n.length-1,r=!1;for(;a>=0;--a)o=n[a],o._active?(o._total>i.duration&&(i.duration=o._total),o.tick(t),r=!0):(n[a]=n[n.length-1],n.pop());r&&(s.draw(),this._notify(s,i,t,"progress")),n.length||(i.running=!1,this._notify(s,i,t,"complete"),i.initial=!1),e+=n.length})),this._lastDate=t,0===e&&(this._running=!1)}_getAnims(t){const e=this._charts;let i=e.get(t);return i||(i={running:!1,initial:!0,items:[],listeners:{complete:[],progress:[]}},e.set(t,i)),i}listen(t,e,i){this._getAnims(t).listeners[e].push(i)}add(t,e){e&&e.length&&this._getAnims(t).items.push(...e)}has(t){return this._getAnims(t).items.length>0}start(t){const e=this._charts.get(t);e&&(e.running=!0,e.start=Date.now(),e.duration=e.items.reduce(((t,e)=>Math.max(t,e._duration)),0),this._refresh())}running(t){if(!this._running)return!1;const e=this._charts.get(t);return!!(e&&e.running&&e.items.length)}stop(t){const e=this._charts.get(t);if(!e||!e.items.length)return;const i=e.items;let s=i.length-1;for(;s>=0;--s)i[s].cancel();e.items=[],this._notify(t,e,Date.now(),"complete")}remove(t){return this._charts.delete(t)}};const ki={boolean:(t,e,i)=>i>.5?e:t,color(t,e,i){const s=$t(t||"transparent"),n=s.valid&&$t(e||"transparent");return n&&n.valid?n.mix(s,i).hexString():e},number:(t,e,i)=>t+(e-t)*i};class Si{constructor(t,e,i,s){const n=e[i];s=be([t.to,s,n,t.from]);const o=be([t.from,n,s]);this._active=!0,this._fn=t.fn||ki[t.type||typeof o],this._easing=lt[t.easing]||lt.linear,this._start=Math.floor(Date.now()+(t.delay||0)),this._duration=this._total=Math.floor(t.duration),this._loop=!!t.loop,this._target=e,this._prop=i,this._from=o,this._to=s,this._promises=void 0}active(){return this._active}update(t,e,i){if(this._active){this._notify(!1);const s=this._target[this._prop],n=i-this._start,o=this._duration-n;this._start=i,this._duration=Math.floor(Math.max(o,t.duration)),this._total+=n,this._loop=!!t.loop,this._to=be([t.to,e,s,t.from]),this._from=be([t.from,s,e])}}cancel(){this._active&&(this.tick(Date.now()),this._active=!1,this._notify(!1))}tick(t){const e=t-this._start,i=this._duration,s=this._prop,n=this._from,o=this._loop,a=this._to;let r;if(this._active=n!==a&&(o||e1?2-r:r,r=this._easing(Math.min(1,Math.max(0,r))),this._target[s]=this._fn(n,a,r))}wait(){const t=this._promises||(this._promises=[]);return new Promise(((e,i)=>{t.push({res:e,rej:i})}))}_notify(t){const e=t?"res":"rej",i=this._promises||[];for(let t=0;t"onProgress"!==t&&"onComplete"!==t&&"fn"!==t}),Jt.set("animations",{colors:{type:"color",properties:["color","borderColor","backgroundColor"]},numbers:{type:"number",properties:["x","y","borderWidth","radius","tension"]}}),Jt.describe("animations",{_fallback:"animation"}),Jt.set("transitions",{active:{animation:{duration:400}},resize:{animation:{duration:0}},show:{animations:{colors:{from:"transparent"},visible:{type:"boolean",duration:0}}},hide:{animations:{colors:{to:"transparent"},visible:{type:"boolean",easing:"linear",fn:t=>0|t}}}});class Di{constructor(t,e){this._chart=t,this._properties=new Map,this.configure(e)}configure(t){if(!u(t))return;const e=this._properties;Object.getOwnPropertyNames(t).forEach((i=>{const s=t[i];if(!u(s))return;const n={};for(const t of Pi)n[t]=s[t];(d(s.properties)&&s.properties||[i]).forEach((t=>{t!==i&&e.has(t)||e.set(t,n)}))}))}_animateOptions(t,e){const i=e.options,s=function(t,e){if(!e)return;let i=t.options;if(!i)return void(t.options=e);i.$shared&&(t.options=i=Object.assign({},i,{$shared:!1,$animations:{}}));return i}(t,i);if(!s)return[];const n=this._createAnimations(s,i);return i.$shared&&function(t,e){const i=[],s=Object.keys(e);for(let e=0;e{t.options=i}),(()=>{})),n}_createAnimations(t,e){const i=this._properties,s=[],n=t.$animations||(t.$animations={}),o=Object.keys(e),a=Date.now();let r;for(r=o.length-1;r>=0;--r){const l=o[r];if("$"===l.charAt(0))continue;if("options"===l){s.push(...this._animateOptions(t,e));continue}const h=e[l];let c=n[l];const d=i.get(l);if(c){if(d&&c.active()){c.update(d,h,a);continue}c.cancel()}d&&d.duration?(n[l]=c=new Si(d,t,l,h),s.push(c)):t[l]=h}return s}update(t,e){if(0===this._properties.size)return void Object.assign(t,e);const i=this._createAnimations(t,e);return i.length?(Mi.add(this._chart,i),!0):void 0}}function Ci(t,e){const i=t&&t.options||{},s=i.reverse,n=void 0===i.min?e:0,o=void 0===i.max?e:0;return{start:s?o:n,end:s?n:o}}function Oi(t,e){const i=[],s=t._getSortedDatasetMetas(e);let n,o;for(n=0,o=s.length;n0||!i&&e<0)return n.index}return null}function Ei(t,e){const{chart:i,_cachedMeta:s}=t,n=i._stacks||(i._stacks={}),{iScale:o,vScale:a,index:r}=s,l=o.axis,h=a.axis,c=function(t,e,i){return`${t.id}.${e.id}.${i.stack||i.type}`}(o,a,s),d=e.length;let u;for(let t=0;ti[t].axis===e)).shift()}function zi(t,e){const i=t.controller.index,s=t.vScale&&t.vScale.axis;if(s){e=e||t._parsed;for(const t of e){const e=t._stacks;if(!e||void 0===e[s]||void 0===e[s][i])return;delete e[s][i]}}}const Fi=t=>"reset"===t||"none"===t,Wi=(t,e)=>e?t:Object.assign({},t);class Vi{constructor(t,e){this.chart=t,this._ctx=t.ctx,this.index=e,this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this.options=void 0,this._parsing=!1,this._data=void 0,this._objectData=void 0,this._sharedOptions=void 0,this._drawStart=void 0,this._drawCount=void 0,this.enableOptionSharing=!1,this.supportsDecimation=!1,this.$context=void 0,this._syncList=[],this.initialize()}initialize(){const t=this._cachedMeta;this.configure(),this.linkScales(),t._stacked=Ti(t.vScale,t),this.addElements()}updateIndex(t){this.index!==t&&zi(this._cachedMeta),this.index=t}linkScales(){const t=this.chart,e=this._cachedMeta,i=this.getDataset(),s=(t,e,i,s)=>"x"===t?e:"r"===t?s:i,n=e.xAxisID=p(i.xAxisID,Ii(t,"x")),o=e.yAxisID=p(i.yAxisID,Ii(t,"y")),a=e.rAxisID=p(i.rAxisID,Ii(t,"r")),r=e.indexAxis,l=e.iAxisID=s(r,n,o,a),h=e.vAxisID=s(r,o,n,a);e.xScale=this.getScaleForId(n),e.yScale=this.getScaleForId(o),e.rScale=this.getScaleForId(a),e.iScale=this.getScaleForId(l),e.vScale=this.getScaleForId(h)}getDataset(){return this.chart.data.datasets[this.index]}getMeta(){return this.chart.getDatasetMeta(this.index)}getScaleForId(t){return this.chart.scales[t]}_getOtherScale(t){const e=this._cachedMeta;return t===e.iScale?e.vScale:e.iScale}reset(){this._update("reset")}_destroy(){const t=this._cachedMeta;this._data&&Pe(this._data,this),t._stacked&&zi(t)}_dataCheck(){const t=this.getDataset(),e=t.data||(t.data=[]),i=this._data;if(u(e))this._data=function(t){const e=Object.keys(t),i=new Array(e.length);let s,n,o;for(s=0,n=e.length;s{const e="_onData"+C(t),i=s[t];Object.defineProperty(s,t,{configurable:!0,enumerable:!1,value(...t){const n=i.apply(this,t);return s._chartjs.listeners.forEach((i=>{"function"==typeof i[e]&&i[e](...t)})),n}})})))),this._syncList=[],this._data=e}var s,n}addElements(){const t=this._cachedMeta;this._dataCheck(),this.datasetElementType&&(t.dataset=new this.datasetElementType)}buildOrUpdateElements(t){const e=this._cachedMeta,i=this.getDataset();let s=!1;this._dataCheck();const n=e._stacked;e._stacked=Ti(e.vScale,e),e.stack!==i.stack&&(s=!0,zi(e),e.stack=i.stack),this._resyncElements(t),(s||n!==e._stacked)&&Ei(this,e._parsed)}configure(){const t=this.chart.config,e=t.datasetScopeKeys(this._type),i=t.getOptionScopes(this.getDataset(),e,!0);this.options=t.createResolver(i,this.getContext()),this._parsing=this.options.parsing,this._cachedDataOpts={}}parse(t,e){const{_cachedMeta:i,_data:s}=this,{iScale:n,_stacked:o}=i,a=n.axis;let r,l,h,c=0===t&&e===s.length||i._sorted,f=t>0&&i._parsed[t-1];if(!1===this._parsing)i._parsed=s,i._sorted=!0,h=s;else{h=d(s[t])?this.parseArrayData(i,s,t,e):u(s[t])?this.parseObjectData(i,s,t,e):this.parsePrimitiveData(i,s,t,e);const n=()=>null===l[a]||f&&l[a]t&&!e.hidden&&e._stacked&&{keys:Oi(i,!0),values:null})(e,i,this.chart),l={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY},{min:h,max:c}=function(t){const{min:e,max:i,minDefined:s,maxDefined:n}=t.getUserBounds();return{min:s?e:Number.NEGATIVE_INFINITY,max:n?i:Number.POSITIVE_INFINITY}}(a);let d,u;function g(){u=s[d];const e=u[a.axis];return!f(u[t.axis])||h>e||c=0;--d)if(!g()){this.updateRangeFromParsed(l,t,u,r);break}return l}getAllParsedValues(t){const e=this._cachedMeta._parsed,i=[];let s,n,o;for(s=0,n=e.length;s=0&&tthis.getContext(i,s)),c);return f.$shared&&(f.$shared=r,n[o]=Object.freeze(Wi(f,r))),f}_resolveAnimations(t,e,i){const s=this.chart,n=this._cachedDataOpts,o=`animation-${e}`,a=n[o];if(a)return a;let r;if(!1!==s.options.animation){const s=this.chart.config,n=s.datasetAnimationScopeKeys(this._type,e),o=s.getOptionScopes(this.getDataset(),n);r=s.createResolver(o,this.getContext(t,i,e))}const l=new Di(s,r&&r.animations);return r&&r._cacheable&&(n[o]=Object.freeze(l)),l}getSharedOptions(t){if(t.$shared)return this._sharedOptions||(this._sharedOptions=Object.assign({},t))}includeOptions(t,e){return!e||Fi(t)||this.chart._animationsDisabled}updateElement(t,e,i,s){Fi(s)?Object.assign(t,i):this._resolveAnimations(e,s).update(t,i)}updateSharedOptions(t,e,i){t&&!Fi(e)&&this._resolveAnimations(void 0,e).update(t,i)}_setStyle(t,e,i,s){t.active=s;const n=this.getStyle(e,s);this._resolveAnimations(e,i,s).update(t,{options:!s&&this.getSharedOptions(n)||n})}removeHoverStyle(t,e,i){this._setStyle(t,i,"active",!1)}setHoverStyle(t,e,i){this._setStyle(t,i,"active",!0)}_removeDatasetHoverStyle(){const t=this._cachedMeta.dataset;t&&this._setStyle(t,void 0,"active",!1)}_setDatasetHoverStyle(){const t=this._cachedMeta.dataset;t&&this._setStyle(t,void 0,"active",!0)}_resyncElements(t){const e=this._data,i=this._cachedMeta.data;for(const[t,e,i]of this._syncList)this[t](e,i);this._syncList=[];const s=i.length,n=e.length,o=Math.min(n,s);o&&this.parse(0,o),n>s?this._insertElements(s,n-s,t):n{for(t.length+=e,a=t.length-1;a>=o;a--)t[a]=t[a-e]};for(r(n),a=t;at-e)))}return t._cache.$bar}(e,t.type);let s,n,o,a,r=e._length;const l=()=>{32767!==o&&-32768!==o&&(O(a)&&(r=Math.min(r,Math.abs(o-a)||r)),a=o)};for(s=0,n=i.length;sMath.abs(r)&&(l=r,h=a),e[i.axis]=h,e._custom={barStart:l,barEnd:h,start:n,end:o,min:a,max:r}}(t,e,i,s):e[i.axis]=i.parse(t,s),e}function Ni(t,e,i,s){const n=t.iScale,o=t.vScale,a=n.getLabels(),r=n===o,l=[];let h,c,d,u;for(h=i,c=i+s;ht.x,i="left",s="right"):(e=t.base=i?1:-1)}(d,e,o)*n,u===o&&(m-=d/2);const t=e.getPixelForDecimal(0),i=e.getPixelForDecimal(1),s=Math.min(t,i),a=Math.max(t,i);m=Math.max(Math.min(m,a),s),h=m+d}if(m===e.getPixelForValue(o)){const t=N(d)*e.getLineWidthForValue(o)/2;m+=t,d-=t}return{size:d,base:m,head:h,center:h+d/2}}_calculateBarIndexPixels(t,e){const i=e.scale,s=this.options,n=s.skipNull,o=p(s.maxBarThickness,1/0);let a,r;if(e.grouped){const i=n?this._getStackCount(t):e.stackCount,l="flex"===s.barThickness?function(t,e,i,s){const n=e.pixels,o=n[t];let a=t>0?n[t-1]:null,r=t=0;--i)e=Math.max(e,t[i].size(this.resolveDataElementOptions(i))/2);return e>0&&e}getLabelAndValue(t){const e=this._cachedMeta,{xScale:i,yScale:s}=e,n=this.getParsed(t),o=i.getLabelForValue(n.x),a=s.getLabelForValue(n.y),r=n._custom;return{label:e.label,value:"("+o+", "+a+(r?", "+r:"")+")"}}update(t){const e=this._cachedMeta.data;this.updateElements(e,0,e.length,t)}updateElements(t,e,i,s){const n="reset"===s,{iScale:o,vScale:a}=this._cachedMeta,r=this.resolveDataElementOptions(e,s),l=this.getSharedOptions(r),h=this.includeOptions(s,l),c=o.axis,d=a.axis;for(let r=e;r""}}}};class Ji extends Vi{constructor(t,e){super(t,e),this.enableOptionSharing=!0,this.innerRadius=void 0,this.outerRadius=void 0,this.offsetX=void 0,this.offsetY=void 0}linkScales(){}parse(t,e){const i=this.getDataset().data,s=this._cachedMeta;if(!1===this._parsing)s._parsed=i;else{let n,o,a=t=>+i[t];if(u(i[t])){const{key:t="value"}=this._parsing;a=e=>+D(i[e],t)}for(n=t,o=t+e;nit(t,r,l,!0)?1:Math.max(e,e*i,s,s*i),g=(t,e,s)=>it(t,r,l,!0)?-1:Math.min(e,e*i,s,s*i),p=f(0,h,d),m=f(W,c,u),x=g(L,h,d),b=g(L+W,c,u);s=(p-x)/2,n=(m-b)/2,o=-(p+x)/2,a=-(m+b)/2}return{ratioX:s,ratioY:n,offsetX:o,offsetY:a}}(u,d,r),b=(i.width-o)/f,y=(i.height-o)/g,_=Math.max(Math.min(b,y)/2,0),v=m(this.options.radius,_),w=(v-Math.max(v*r,0))/this._getVisibleDatasetWeightTotal();this.offsetX=p*v,this.offsetY=x*v,s.total=this.calculateTotal(),this.outerRadius=v-w*this._getRingWeightOffset(this.index),this.innerRadius=Math.max(this.outerRadius-w*c,0),this.updateElements(n,0,n.length,t)}_circumference(t,e){const i=this.options,s=this._cachedMeta,n=this._getCircumference();return e&&i.animation.animateRotate||!this.chart.getDataVisibility(t)||null===s._parsed[t]||s.data[t].hidden?0:this.calculateCircumference(s._parsed[t]*n/E)}updateElements(t,e,i,s){const n="reset"===s,o=this.chart,a=o.chartArea,r=o.options.animation,l=(a.left+a.right)/2,h=(a.top+a.bottom)/2,c=n&&r.animateScale,d=c?0:this.innerRadius,u=c?0:this.outerRadius,f=this.resolveDataElementOptions(e,s),g=this.getSharedOptions(f),p=this.includeOptions(s,g);let m,x=this._getRotation();for(m=0;m0&&!isNaN(t)?E*(Math.abs(t)/e):0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=di(e._parsed[t],i.options.locale);return{label:s[t]||"",value:n}}getMaxBorderWidth(t){let e=0;const i=this.chart;let s,n,o,a,r;if(!t)for(s=0,n=i.data.datasets.length;s"spacing"!==t,_indexable:t=>"spacing"!==t},Ji.overrides={aspectRatio:1,plugins:{legend:{labels:{generateLabels(t){const e=t.data;if(e.labels.length&&e.datasets.length){const{labels:{pointStyle:i}}=t.legend.options;return e.labels.map(((e,s)=>{const n=t.getDatasetMeta(0).controller.getStyle(s);return{text:e,fillStyle:n.backgroundColor,strokeStyle:n.borderColor,lineWidth:n.borderWidth,pointStyle:i,hidden:!t.getDataVisibility(s),index:s}}))}return[]}},onClick(t,e,i){i.chart.toggleDataVisibility(e.index),i.chart.update()}},tooltip:{callbacks:{title:()=>"",label(t){let e=t.label;const i=": "+t.formattedValue;return d(e)?(e=e.slice(),e[0]+=i):e+=i,e}}}}};class Gi extends Vi{initialize(){this.enableOptionSharing=!0,this.supportsDecimation=!0,super.initialize()}update(t){const e=this._cachedMeta,{dataset:i,data:s=[],_dataset:n}=e,o=this.chart._animationsDisabled;let{start:a,count:r}=function(t,e,i){const s=e.length;let n=0,o=s;if(t._sorted){const{iScale:a,_parsed:r}=t,l=a.axis,{min:h,max:c,minDefined:d,maxDefined:u}=a.getUserBounds();d&&(n=st(Math.min(we(r,a.axis,h).lo,i?s:we(e,l,a.getPixelForValue(h)).lo),0,s-1)),o=u?st(Math.max(we(r,a.axis,c).hi+1,i?0:we(e,l,a.getPixelForValue(c)).hi+1),n,s)-n:s-n}return{start:n,count:o}}(e,s,o);this._drawStart=a,this._drawCount=r,function(t){const{xScale:e,yScale:i,_scaleRanges:s}=t,n={xmin:e.min,xmax:e.max,ymin:i.min,ymax:i.max};if(!s)return t._scaleRanges=n,!0;const o=s.xmin!==e.min||s.xmax!==e.max||s.ymin!==i.min||s.ymax!==i.max;return Object.assign(s,n),o}(e)&&(a=0,r=s.length),i._chart=this.chart,i._datasetIndex=this.index,i._decimated=!!n._decimated,i.points=s;const l=this.resolveDatasetElementOptions(t);this.options.showLine||(l.borderWidth=0),l.segment=this.options.segment,this.updateElement(i,void 0,{animated:!o,options:l},t),this.updateElements(s,a,r,t)}updateElements(t,e,i,s){const n="reset"===s,{iScale:o,vScale:a,_stacked:r,_dataset:l}=this._cachedMeta,h=this.resolveDataElementOptions(e,s),d=this.getSharedOptions(h),u=this.includeOptions(s,d),f=o.axis,g=a.axis,{spanGaps:p,segment:m}=this.options,x=Y(p)?p:Number.POSITIVE_INFINITY,b=this.chart._animationsDisabled||n||"none"===s;let y=e>0&&this.getParsed(e-1);for(let h=e;h0&&Math.abs(i[f]-y[f])>x,m&&(p.parsed=i,p.raw=l.data[h]),u&&(p.options=d||this.resolveDataElementOptions(h,e.active?"active":s)),b||this.updateElement(e,h,p,s),y=i}this.updateSharedOptions(d,s,h)}getMaxOverflow(){const t=this._cachedMeta,e=t.dataset,i=e.options&&e.options.borderWidth||0,s=t.data||[];if(!s.length)return i;const n=s[0].size(this.resolveDataElementOptions(0)),o=s[s.length-1].size(this.resolveDataElementOptions(s.length-1));return Math.max(i,n,o)/2}draw(){const t=this._cachedMeta;t.dataset.updateControlPoints(this.chart.chartArea,t.iScale.axis),super.draw()}}Gi.id="line",Gi.defaults={datasetElementType:"line",dataElementType:"point",showLine:!0,spanGaps:!1},Gi.overrides={scales:{_index_:{type:"category"},_value_:{type:"linear"}}};class Zi extends Vi{constructor(t,e){super(t,e),this.innerRadius=void 0,this.outerRadius=void 0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=di(e._parsed[t].r,i.options.locale);return{label:s[t]||"",value:n}}parseObjectData(t,e,i,s){return Be.bind(this)(t,e,i,s)}update(t){const e=this._cachedMeta.data;this._updateRadius(),this.updateElements(e,0,e.length,t)}getMinMax(){const t=this._cachedMeta,e={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY};return t.data.forEach(((t,i)=>{const s=this.getParsed(i).r;!isNaN(s)&&this.chart.getDataVisibility(i)&&(se.max&&(e.max=s))})),e}_updateRadius(){const t=this.chart,e=t.chartArea,i=t.options,s=Math.min(e.right-e.left,e.bottom-e.top),n=Math.max(s/2,0),o=(n-Math.max(i.cutoutPercentage?n/100*i.cutoutPercentage:1,0))/t.getVisibleDatasetCount();this.outerRadius=n-o*this.index,this.innerRadius=this.outerRadius-o}updateElements(t,e,i,s){const n="reset"===s,o=this.chart,a=o.options.animation,r=this._cachedMeta.rScale,l=r.xCenter,h=r.yCenter,c=r.getIndexAngle(0)-.5*L;let d,u=c;const f=360/this.countVisibleElements();for(d=0;d{!isNaN(this.getParsed(i).r)&&this.chart.getDataVisibility(i)&&e++})),e}_computeAngle(t,e,i){return this.chart.getDataVisibility(t)?K(this.resolveDataElementOptions(t,e).angle||i):0}}Zi.id="polarArea",Zi.defaults={dataElementType:"arc",animation:{animateRotate:!0,animateScale:!0},animations:{numbers:{type:"number",properties:["x","y","startAngle","endAngle","innerRadius","outerRadius"]}},indexAxis:"r",startAngle:0},Zi.overrides={aspectRatio:1,plugins:{legend:{labels:{generateLabels(t){const e=t.data;if(e.labels.length&&e.datasets.length){const{labels:{pointStyle:i}}=t.legend.options;return e.labels.map(((e,s)=>{const n=t.getDatasetMeta(0).controller.getStyle(s);return{text:e,fillStyle:n.backgroundColor,strokeStyle:n.borderColor,lineWidth:n.borderWidth,pointStyle:i,hidden:!t.getDataVisibility(s),index:s}}))}return[]}},onClick(t,e,i){i.chart.toggleDataVisibility(e.index),i.chart.update()}},tooltip:{callbacks:{title:()=>"",label:t=>t.chart.data.labels[t.dataIndex]+": "+t.formattedValue}}},scales:{r:{type:"radialLinear",angleLines:{display:!1},beginAtZero:!0,grid:{circular:!0},pointLabels:{display:!1},startAngle:0}}};class Qi extends Ji{}Qi.id="pie",Qi.defaults={cutout:0,rotation:0,circumference:360,radius:"100%"};class ts extends Vi{getLabelAndValue(t){const e=this._cachedMeta.vScale,i=this.getParsed(t);return{label:e.getLabels()[t],value:""+e.getLabelForValue(i[e.axis])}}parseObjectData(t,e,i,s){return Be.bind(this)(t,e,i,s)}update(t){const e=this._cachedMeta,i=e.dataset,s=e.data||[],n=e.iScale.getLabels();if(i.points=s,"resize"!==t){const e=this.resolveDatasetElementOptions(t);this.options.showLine||(e.borderWidth=0);const o={_loop:!0,_fullLoop:n.length===s.length,options:e};this.updateElement(i,void 0,o,t)}this.updateElements(s,0,s.length,t)}updateElements(t,e,i,s){const n=this._cachedMeta.rScale,o="reset"===s;for(let a=e;a"",label:t=>"("+t.label+", "+t.formattedValue+")"}}},scales:{x:{type:"linear"},y:{type:"linear"}}};var is=Object.freeze({__proto__:null,BarController:qi,BubbleController:Ki,DoughnutController:Ji,LineController:Gi,PolarAreaController:Zi,PieController:Qi,RadarController:ts,ScatterController:es});function ss(){throw new Error("This method is not implemented: Check that a complete date adapter is provided.")}class ns{constructor(t){this.options=t||{}}formats(){return ss()}parse(t,e){return ss()}format(t,e){return ss()}add(t,e,i){return ss()}diff(t,e,i){return ss()}startOf(t,e,i){return ss()}endOf(t,e){return ss()}}ns.override=function(t){Object.assign(ns.prototype,t)};var os={_date:ns};function as(t,e,i,s){const{controller:n,data:o,_sorted:a}=t,r=n._cachedMeta.iScale;if(r&&e===r.axis&&"r"!==e&&a&&o.length){const t=r._reversePixels?Me:we;if(!s)return t(o,e,i);if(n._sharedOptions){const s=o[0],n="function"==typeof s.getRange&&s.getRange(e);if(n){const s=t(o,e,i-n),a=t(o,e,i+n);return{lo:s.lo,hi:a.hi}}}}return{lo:0,hi:o.length-1}}function rs(t,e,i,s,n){const o=t.getSortedVisibleDatasetMetas(),a=i[e];for(let t=0,i=o.length;t{t[a](e[i],n)&&(o.push({element:t,datasetIndex:s,index:l}),r=r||t.inRange(e.x,e.y,n))})),s&&!r?[]:o}var us={evaluateInteractionItems:rs,modes:{index(t,e,i,s){const n=ei(e,t),o=i.axis||"x",a=i.includeInvisible||!1,r=i.intersect?ls(t,n,o,s,a):cs(t,n,o,!1,s,a),l=[];return r.length?(t.getSortedVisibleDatasetMetas().forEach((t=>{const e=r[0].index,i=t.data[e];i&&!i.skip&&l.push({element:i,datasetIndex:t.index,index:e})})),l):[]},dataset(t,e,i,s){const n=ei(e,t),o=i.axis||"xy",a=i.includeInvisible||!1;let r=i.intersect?ls(t,n,o,s,a):cs(t,n,o,!1,s,a);if(r.length>0){const e=r[0].datasetIndex,i=t.getDatasetMeta(e).data;r=[];for(let t=0;tls(t,ei(e,t),i.axis||"xy",s,i.includeInvisible||!1),nearest(t,e,i,s){const n=ei(e,t),o=i.axis||"xy",a=i.includeInvisible||!1;return cs(t,n,o,i.intersect,s,a)},x:(t,e,i,s)=>ds(t,ei(e,t),"x",i.intersect,s),y:(t,e,i,s)=>ds(t,ei(e,t),"y",i.intersect,s)}};const fs=["left","top","right","bottom"];function gs(t,e){return t.filter((t=>t.pos===e))}function ps(t,e){return t.filter((t=>-1===fs.indexOf(t.pos)&&t.box.axis===e))}function ms(t,e){return t.sort(((t,i)=>{const s=e?i:t,n=e?t:i;return s.weight===n.weight?s.index-n.index:s.weight-n.weight}))}function xs(t,e){const i=function(t){const e={};for(const i of t){const{stack:t,pos:s,stackWeight:n}=i;if(!t||!fs.includes(s))continue;const o=e[t]||(e[t]={count:0,placed:0,weight:0,size:0});o.count++,o.weight+=n}return e}(t),{vBoxMaxWidth:s,hBoxMaxHeight:n}=e;let o,a,r;for(o=0,a=t.length;o{s[t]=Math.max(e[t],i[t])})),s}return s(t?["left","right"]:["top","bottom"])}function ws(t,e,i,s){const n=[];let o,a,r,l,h,c;for(o=0,a=t.length,h=0;ot.box.fullSize)),!0),s=ms(gs(e,"left"),!0),n=ms(gs(e,"right")),o=ms(gs(e,"top"),!0),a=ms(gs(e,"bottom")),r=ps(e,"x"),l=ps(e,"y");return{fullSize:i,leftAndTop:s.concat(o),rightAndBottom:n.concat(l).concat(a).concat(r),chartArea:gs(e,"chartArea"),vertical:s.concat(n).concat(l),horizontal:o.concat(a).concat(r)}}(t.boxes),l=r.vertical,h=r.horizontal;b(t.boxes,(t=>{"function"==typeof t.beforeLayout&&t.beforeLayout()}));const c=l.reduce(((t,e)=>e.box.options&&!1===e.box.options.display?t:t+1),0)||1,d=Object.freeze({outerWidth:e,outerHeight:i,padding:n,availableWidth:o,availableHeight:a,vBoxMaxWidth:o/2/c,hBoxMaxHeight:a/2}),u=Object.assign({},n);ys(u,me(s));const f=Object.assign({maxPadding:u,w:o,h:a,x:n.left,y:n.top},n),g=xs(l.concat(h),d);ws(r.fullSize,f,d,g),ws(l,f,d,g),ws(h,f,d,g)&&ws(l,f,d,g),function(t){const e=t.maxPadding;function i(i){const s=Math.max(e[i]-t[i],0);return t[i]+=s,s}t.y+=i("top"),t.x+=i("left"),i("right"),i("bottom")}(f),ks(r.leftAndTop,f,d,g),f.x+=f.w,f.y+=f.h,ks(r.rightAndBottom,f,d,g),t.chartArea={left:f.left,top:f.top,right:f.left+f.w,bottom:f.top+f.h,height:f.h,width:f.w},b(r.chartArea,(e=>{const i=e.box;Object.assign(i,t.chartArea),i.update(f.w,f.h,{left:0,top:0,right:0,bottom:0})}))}};class Ps{acquireContext(t,e){}releaseContext(t){return!1}addEventListener(t,e,i){}removeEventListener(t,e,i){}getDevicePixelRatio(){return 1}getMaximumSize(t,e,i,s){return e=Math.max(0,e||t.width),i=i||t.height,{width:e,height:Math.max(0,s?Math.floor(e/s):i)}}isAttached(t){return!0}updateConfig(t){}}class Ds extends Ps{acquireContext(t){return t&&t.getContext&&t.getContext("2d")||null}updateConfig(t){t.options.animation=!1}}const Cs={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"},Os=t=>null===t||""===t;const As=!!oi&&{passive:!0};function Ts(t,e,i){t.canvas.removeEventListener(e,i,As)}function Rs(t,e){for(const i of t)if(i===e||i.contains(e))return!0}function Ls(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||Rs(i.addedNodes,s),e=e&&!Rs(i.removedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}function Es(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||Rs(i.removedNodes,s),e=e&&!Rs(i.addedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}const Is=new Map;let zs=0;function Fs(){const t=window.devicePixelRatio;t!==zs&&(zs=t,Is.forEach(((e,i)=>{i.currentDevicePixelRatio!==t&&e()})))}function Ws(t,e,i){const n=t.canvas,o=n&&Je(n);if(!o)return;const a=s(((t,e)=>{const s=o.clientWidth;i(t,e),s{const e=t[0],i=e.contentRect.width,s=e.contentRect.height;0===i&&0===s||a(i,s)}));return r.observe(o),function(t,e){Is.size||window.addEventListener("resize",Fs),Is.set(t,e)}(t,a),r}function Vs(t,e,i){i&&i.disconnect(),"resize"===e&&function(t){Is.delete(t),Is.size||window.removeEventListener("resize",Fs)}(t)}function js(t,e,i){const n=t.canvas,o=s((e=>{null!==t.ctx&&i(function(t,e){const i=Cs[t.type]||t.type,{x:s,y:n}=ei(t,e);return{type:i,chart:e,native:t,x:void 0!==s?s:null,y:void 0!==n?n:null}}(e,t))}),t,(t=>{const e=t[0];return[e,e.offsetX,e.offsetY]}));return function(t,e,i){t.addEventListener(e,i,As)}(n,e,o),o}class Bs extends Ps{acquireContext(t,e){const i=t&&t.getContext&&t.getContext("2d");return i&&i.canvas===t?(function(t,e){const i=t.style,s=t.getAttribute("height"),n=t.getAttribute("width");if(t.$chartjs={initial:{height:s,width:n,style:{display:i.display,height:i.height,width:i.width}}},i.display=i.display||"block",i.boxSizing=i.boxSizing||"border-box",Os(n)){const e=ai(t,"width");void 0!==e&&(t.width=e)}if(Os(s))if(""===t.style.height)t.height=t.width/(e||2);else{const e=ai(t,"height");void 0!==e&&(t.height=e)}}(t,e),i):null}releaseContext(t){const e=t.canvas;if(!e.$chartjs)return!1;const i=e.$chartjs.initial;["height","width"].forEach((t=>{const s=i[t];c(s)?e.removeAttribute(t):e.setAttribute(t,s)}));const s=i.style||{};return Object.keys(s).forEach((t=>{e.style[t]=s[t]})),e.width=e.width,delete e.$chartjs,!0}addEventListener(t,e,i){this.removeEventListener(t,e);const s=t.$proxies||(t.$proxies={}),n={attach:Ls,detach:Es,resize:Ws}[e]||js;s[e]=n(t,e,i)}removeEventListener(t,e){const i=t.$proxies||(t.$proxies={}),s=i[e];if(!s)return;({attach:Vs,detach:Vs,resize:Vs}[e]||Ts)(t,e,s),i[e]=void 0}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(t,e,i,s){return si(t,e,i,s)}isAttached(t){const e=Je(t);return!(!e||!e.isConnected)}}class Ns{constructor(){this.x=void 0,this.y=void 0,this.active=!1,this.options=void 0,this.$animations=void 0}tooltipPosition(t){const{x:e,y:i}=this.getProps(["x","y"],t);return{x:e,y:i}}hasValue(){return Y(this.x)&&Y(this.y)}getProps(t,e){const i=this.$animations;if(!e||!i)return this;const s={};return t.forEach((t=>{s[t]=i[t]&&i[t].active()?i[t]._to:this[t]})),s}}Ns.defaults={},Ns.defaultRoutes=void 0;const Hs={values:t=>d(t)?t:""+t,numeric(t,e,i){if(0===t)return"0";const s=this.chart.options.locale;let n,o=t;if(i.length>1){const e=Math.max(Math.abs(i[0].value),Math.abs(i[i.length-1].value));(e<1e-4||e>1e15)&&(n="scientific"),o=function(t,e){let i=e.length>3?e[2].value-e[1].value:e[1].value-e[0].value;Math.abs(i)>=1&&t!==Math.floor(t)&&(i=t-Math.floor(t));return i}(t,i)}const a=B(Math.abs(o)),r=Math.max(Math.min(-1*Math.floor(a),20),0),l={notation:n,minimumFractionDigits:r,maximumFractionDigits:r};return Object.assign(l,this.options.ticks.format),di(t,s,l)},logarithmic(t,e,i){if(0===t)return"0";const s=t/Math.pow(10,Math.floor(B(t)));return 1===s||2===s||5===s?Hs.numeric.call(this,t,e,i):""}};var $s={formatters:Hs};function Ys(t,e){const i=t.options.ticks,s=i.maxTicksLimit||function(t){const e=t.options.offset,i=t._tickSize(),s=t._length/i+(e?0:1),n=t._maxLength/i;return Math.floor(Math.min(s,n))}(t),n=i.major.enabled?function(t){const e=[];let i,s;for(i=0,s=t.length;is)return function(t,e,i,s){let n,o=0,a=i[0];for(s=Math.ceil(s),n=0;nn)return e}return Math.max(n,1)}(n,e,s);if(o>0){let t,i;const s=o>1?Math.round((r-a)/(o-1)):null;for(Xs(e,l,h,c(s)?0:a-s,a),t=0,i=o-1;te.lineWidth,tickColor:(t,e)=>e.color,offset:!1,borderDash:[],borderDashOffset:0,borderWidth:1},title:{display:!1,text:"",padding:{top:4,bottom:4}},ticks:{minRotation:0,maxRotation:50,mirror:!1,textStrokeWidth:0,textStrokeColor:"",padding:3,display:!0,autoSkip:!0,autoSkipPadding:3,labelOffset:0,callback:$s.formatters.values,minor:{},major:{},align:"center",crossAlign:"near",showLabelBackdrop:!1,backdropColor:"rgba(255, 255, 255, 0.75)",backdropPadding:2}}),Jt.route("scale.ticks","color","","color"),Jt.route("scale.grid","color","","borderColor"),Jt.route("scale.grid","borderColor","","borderColor"),Jt.route("scale.title","color","","color"),Jt.describe("scale",{_fallback:!1,_scriptable:t=>!t.startsWith("before")&&!t.startsWith("after")&&"callback"!==t&&"parser"!==t,_indexable:t=>"borderDash"!==t&&"tickBorderDash"!==t}),Jt.describe("scales",{_fallback:"scale"}),Jt.describe("scale.ticks",{_scriptable:t=>"backdropPadding"!==t&&"callback"!==t,_indexable:t=>"backdropPadding"!==t});const Us=(t,e,i)=>"top"===e||"left"===e?t[e]+i:t[e]-i;function qs(t,e){const i=[],s=t.length/e,n=t.length;let o=0;for(;oa+r)))return h}function Js(t){return t.drawTicks?t.tickLength:0}function Gs(t,e){if(!t.display)return 0;const i=xe(t.font,e),s=me(t.padding);return(d(t.text)?t.text.length:1)*i.lineHeight+s.height}function Zs(t,e,i){let s=o(t);return(i&&"right"!==e||!i&&"right"===e)&&(s=(t=>"left"===t?"right":"right"===t?"left":t)(s)),s}class Qs extends Ns{constructor(t){super(),this.id=t.id,this.type=t.type,this.options=void 0,this.ctx=t.ctx,this.chart=t.chart,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this._margins={left:0,right:0,top:0,bottom:0},this.maxWidth=void 0,this.maxHeight=void 0,this.paddingTop=void 0,this.paddingBottom=void 0,this.paddingLeft=void 0,this.paddingRight=void 0,this.axis=void 0,this.labelRotation=void 0,this.min=void 0,this.max=void 0,this._range=void 0,this.ticks=[],this._gridLineItems=null,this._labelItems=null,this._labelSizes=null,this._length=0,this._maxLength=0,this._longestTextCache={},this._startPixel=void 0,this._endPixel=void 0,this._reversePixels=!1,this._userMax=void 0,this._userMin=void 0,this._suggestedMax=void 0,this._suggestedMin=void 0,this._ticksLength=0,this._borderValue=0,this._cache={},this._dataLimitsCached=!1,this.$context=void 0}init(t){this.options=t.setContext(this.getContext()),this.axis=t.axis,this._userMin=this.parse(t.min),this._userMax=this.parse(t.max),this._suggestedMin=this.parse(t.suggestedMin),this._suggestedMax=this.parse(t.suggestedMax)}parse(t,e){return t}getUserBounds(){let{_userMin:t,_userMax:e,_suggestedMin:i,_suggestedMax:s}=this;return t=g(t,Number.POSITIVE_INFINITY),e=g(e,Number.NEGATIVE_INFINITY),i=g(i,Number.POSITIVE_INFINITY),s=g(s,Number.NEGATIVE_INFINITY),{min:g(t,i),max:g(e,s),minDefined:f(t),maxDefined:f(e)}}getMinMax(t){let e,{min:i,max:s,minDefined:n,maxDefined:o}=this.getUserBounds();if(n&&o)return{min:i,max:s};const a=this.getMatchingVisibleMetas();for(let r=0,l=a.length;rs?s:i,s=n&&i>s?i:s,{min:g(i,g(s,i)),max:g(s,g(i,s))}}getPadding(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}}getTicks(){return this.ticks}getLabels(){const t=this.chart.data;return this.options.labels||(this.isHorizontal()?t.xLabels:t.yLabels)||t.labels||[]}beforeLayout(){this._cache={},this._dataLimitsCached=!1}beforeUpdate(){x(this.options.beforeUpdate,[this])}update(t,e,i){const{beginAtZero:s,grace:n,ticks:o}=this.options,a=o.sampleSize;this.beforeUpdate(),this.maxWidth=t,this.maxHeight=e,this._margins=i=Object.assign({left:0,right:0,top:0,bottom:0},i),this.ticks=null,this._labelSizes=null,this._gridLineItems=null,this._labelItems=null,this.beforeSetDimensions(),this.setDimensions(),this.afterSetDimensions(),this._maxLength=this.isHorizontal()?this.width+i.left+i.right:this.height+i.top+i.bottom,this._dataLimitsCached||(this.beforeDataLimits(),this.determineDataLimits(),this.afterDataLimits(),this._range=ye(this,n,s),this._dataLimitsCached=!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();const r=a=n||i<=1||!this.isHorizontal())return void(this.labelRotation=s);const h=this._getLabelSizes(),c=h.widest.width,d=h.highest.height,u=st(this.chart.width-c,0,this.maxWidth);o=t.offset?this.maxWidth/i:u/(i-1),c+6>o&&(o=u/(i-(t.offset?.5:1)),a=this.maxHeight-Js(t.grid)-e.padding-Gs(t.title,this.chart.options.font),r=Math.sqrt(c*c+d*d),l=J(Math.min(Math.asin(st((h.highest.height+6)/o,-1,1)),Math.asin(st(a/r,-1,1))-Math.asin(st(d/r,-1,1)))),l=Math.max(s,Math.min(n,l))),this.labelRotation=l}afterCalculateLabelRotation(){x(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){x(this.options.beforeFit,[this])}fit(){const t={width:0,height:0},{chart:e,options:{ticks:i,title:s,grid:n}}=this,o=this._isVisible(),a=this.isHorizontal();if(o){const o=Gs(s,e.options.font);if(a?(t.width=this.maxWidth,t.height=Js(n)+o):(t.height=this.maxHeight,t.width=Js(n)+o),i.display&&this.ticks.length){const{first:e,last:s,widest:n,highest:o}=this._getLabelSizes(),r=2*i.padding,l=K(this.labelRotation),h=Math.cos(l),c=Math.sin(l);if(a){const e=i.mirror?0:c*n.width+h*o.height;t.height=Math.min(this.maxHeight,t.height+e+r)}else{const e=i.mirror?0:h*n.width+c*o.height;t.width=Math.min(this.maxWidth,t.width+e+r)}this._calculatePadding(e,s,c,h)}}this._handleMargins(),a?(this.width=this._length=e.width-this._margins.left-this._margins.right,this.height=t.height):(this.width=t.width,this.height=this._length=e.height-this._margins.top-this._margins.bottom)}_calculatePadding(t,e,i,s){const{ticks:{align:n,padding:o},position:a}=this.options,r=0!==this.labelRotation,l="top"!==a&&"x"===this.axis;if(this.isHorizontal()){const a=this.getPixelForTick(0)-this.left,h=this.right-this.getPixelForTick(this.ticks.length-1);let c=0,d=0;r?l?(c=s*t.width,d=i*e.height):(c=i*t.height,d=s*e.width):"start"===n?d=e.width:"end"===n?c=t.width:"inner"!==n&&(c=t.width/2,d=e.width/2),this.paddingLeft=Math.max((c-a+o)*this.width/(this.width-a),0),this.paddingRight=Math.max((d-h+o)*this.width/(this.width-h),0)}else{let i=e.height/2,s=t.height/2;"start"===n?(i=0,s=t.height):"end"===n&&(i=e.height,s=0),this.paddingTop=i+o,this.paddingBottom=s+o}}_handleMargins(){this._margins&&(this._margins.left=Math.max(this.paddingLeft,this._margins.left),this._margins.top=Math.max(this.paddingTop,this._margins.top),this._margins.right=Math.max(this.paddingRight,this._margins.right),this._margins.bottom=Math.max(this.paddingBottom,this._margins.bottom))}afterFit(){x(this.options.afterFit,[this])}isHorizontal(){const{axis:t,position:e}=this.options;return"top"===e||"bottom"===e||"x"===t}isFullSize(){return this.options.fullSize}_convertTicksToLabels(t){let e,i;for(this.beforeTickToLabelConversion(),this.generateTickLabels(t),e=0,i=t.length;e{const i=t.gc,s=i.length/2;let n;if(s>e){for(n=0;n({width:n[t]||0,height:o[t]||0});return{first:k(0),last:k(e-1),widest:k(w),highest:k(M),widths:n,heights:o}}getLabelForValue(t){return t}getPixelForValue(t,e){return NaN}getValueForPixel(t){}getPixelForTick(t){const e=this.ticks;return t<0||t>e.length-1?null:this.getPixelForValue(e[t].value)}getPixelForDecimal(t){this._reversePixels&&(t=1-t);const e=this._startPixel+t*this._length;return st(this._alignToPixels?Qt(this.chart,e,0):e,-32768,32767)}getDecimalForPixel(t){const e=(t-this._startPixel)/this._length;return this._reversePixels?1-e:e}getBasePixel(){return this.getPixelForValue(this.getBaseValue())}getBaseValue(){const{min:t,max:e}=this;return t<0&&e<0?e:t>0&&e>0?t:0}getContext(t){const e=this.ticks||[];if(t>=0&&ta*s?a/i:r/s:r*s0}_computeGridLineItems(t){const e=this.axis,i=this.chart,s=this.options,{grid:n,position:o}=s,a=n.offset,r=this.isHorizontal(),l=this.ticks.length+(a?1:0),h=Js(n),c=[],d=n.setContext(this.getContext()),f=d.drawBorder?d.borderWidth:0,g=f/2,m=function(t){return Qt(i,t,f)};let x,b,y,_,v,w,M,k,S,P,D,C;if("top"===o)x=m(this.bottom),w=this.bottom-h,k=x-g,P=m(t.top)+g,C=t.bottom;else if("bottom"===o)x=m(this.top),P=t.top,C=m(t.bottom)-g,w=x+g,k=this.top+h;else if("left"===o)x=m(this.right),v=this.right-h,M=x-g,S=m(t.left)+g,D=t.right;else if("right"===o)x=m(this.left),S=t.left,D=m(t.right)-g,v=x+g,M=this.left+h;else if("x"===e){if("center"===o)x=m((t.top+t.bottom)/2+.5);else if(u(o)){const t=Object.keys(o)[0],e=o[t];x=m(this.chart.scales[t].getPixelForValue(e))}P=t.top,C=t.bottom,w=x+g,k=w+h}else if("y"===e){if("center"===o)x=m((t.left+t.right)/2);else if(u(o)){const t=Object.keys(o)[0],e=o[t];x=m(this.chart.scales[t].getPixelForValue(e))}v=x-g,M=v-h,S=t.left,D=t.right}const O=p(s.ticks.maxTicksLimit,l),A=Math.max(1,Math.ceil(l/O));for(b=0;be.value===t));if(i>=0){return e.setContext(this.getContext(i)).lineWidth}return 0}drawGrid(t){const e=this.options.grid,i=this.ctx,s=this._gridLineItems||(this._gridLineItems=this._computeGridLineItems(t));let n,o;const a=(t,e,s)=>{s.width&&s.color&&(i.save(),i.lineWidth=s.width,i.strokeStyle=s.color,i.setLineDash(s.borderDash||[]),i.lineDashOffset=s.borderDashOffset,i.beginPath(),i.moveTo(t.x,t.y),i.lineTo(e.x,e.y),i.stroke(),i.restore())};if(e.display)for(n=0,o=s.length;n{this.drawBackground(),this.drawGrid(t),this.drawTitle()}},{z:i+1,draw:()=>{this.drawBorder()}},{z:e,draw:t=>{this.drawLabels(t)}}]:[{z:e,draw:t=>{this.draw(t)}}]}getMatchingVisibleMetas(t){const e=this.chart.getSortedVisibleDatasetMetas(),i=this.axis+"AxisID",s=[];let n,o;for(n=0,o=e.length;n{const s=i.split("."),n=s.pop(),o=[t].concat(s).join("."),a=e[i].split("."),r=a.pop(),l=a.join(".");Jt.route(o,n,l,r)}))}(e,t.defaultRoutes);t.descriptors&&Jt.describe(e,t.descriptors)}(t,o,i),this.override&&Jt.override(t.id,t.overrides)),o}get(t){return this.items[t]}unregister(t){const e=this.items,i=t.id,s=this.scope;i in e&&delete e[i],s&&i in Jt[s]&&(delete Jt[s][i],this.override&&delete Xt[i])}}var en=new class{constructor(){this.controllers=new tn(Vi,"datasets",!0),this.elements=new tn(Ns,"elements"),this.plugins=new tn(Object,"plugins"),this.scales=new tn(Qs,"scales"),this._typedRegistries=[this.controllers,this.scales,this.elements]}add(...t){this._each("register",t)}remove(...t){this._each("unregister",t)}addControllers(...t){this._each("register",t,this.controllers)}addElements(...t){this._each("register",t,this.elements)}addPlugins(...t){this._each("register",t,this.plugins)}addScales(...t){this._each("register",t,this.scales)}getController(t){return this._get(t,this.controllers,"controller")}getElement(t){return this._get(t,this.elements,"element")}getPlugin(t){return this._get(t,this.plugins,"plugin")}getScale(t){return this._get(t,this.scales,"scale")}removeControllers(...t){this._each("unregister",t,this.controllers)}removeElements(...t){this._each("unregister",t,this.elements)}removePlugins(...t){this._each("unregister",t,this.plugins)}removeScales(...t){this._each("unregister",t,this.scales)}_each(t,e,i){[...e].forEach((e=>{const s=i||this._getRegistryForType(e);i||s.isForType(e)||s===this.plugins&&e.id?this._exec(t,s,e):b(e,(e=>{const s=i||this._getRegistryForType(e);this._exec(t,s,e)}))}))}_exec(t,e,i){const s=C(t);x(i["before"+s],[],i),e[t](i),x(i["after"+s],[],i)}_getRegistryForType(t){for(let e=0;et.filter((t=>!e.some((e=>t.plugin.id===e.plugin.id))));this._notify(s(e,i),t,"stop"),this._notify(s(i,e),t,"start")}}function nn(t,e){return e||!1!==t?!0===t?{}:t:null}function on(t,e,i,s){const n=t.pluginScopeKeys(e),o=t.getOptionScopes(i,n);return t.createResolver(o,s,[""],{scriptable:!1,indexable:!1,allKeys:!0})}function an(t,e){const i=Jt.datasets[t]||{};return((e.datasets||{})[t]||{}).indexAxis||e.indexAxis||i.indexAxis||"x"}function rn(t,e){return"x"===t||"y"===t?t:e.axis||("top"===(i=e.position)||"bottom"===i?"x":"left"===i||"right"===i?"y":void 0)||t.charAt(0).toLowerCase();var i}function ln(t){const e=t.options||(t.options={});e.plugins=p(e.plugins,{}),e.scales=function(t,e){const i=Xt[t.type]||{scales:{}},s=e.scales||{},n=an(t.type,e),o=Object.create(null),a=Object.create(null);return Object.keys(s).forEach((t=>{const e=s[t];if(!u(e))return console.error(`Invalid scale configuration for scale: ${t}`);if(e._proxy)return console.warn(`Ignoring resolver passed as options for scale: ${t}`);const r=rn(t,e),l=function(t,e){return t===e?"_index_":"_value_"}(r,n),h=i.scales||{};o[r]=o[r]||t,a[t]=k(Object.create(null),[{axis:r},e,h[r],h[l]])})),t.data.datasets.forEach((i=>{const n=i.type||t.type,r=i.indexAxis||an(n,e),l=(Xt[n]||{}).scales||{};Object.keys(l).forEach((t=>{const e=function(t,e){let i=t;return"_index_"===t?i=e:"_value_"===t&&(i="x"===e?"y":"x"),i}(t,r),n=i[e+"AxisID"]||o[e]||e;a[n]=a[n]||Object.create(null),k(a[n],[{axis:e},s[n],l[t]])}))})),Object.keys(a).forEach((t=>{const e=a[t];k(e,[Jt.scales[e.type],Jt.scale])})),a}(t,e)}function hn(t){return(t=t||{}).datasets=t.datasets||[],t.labels=t.labels||[],t}const cn=new Map,dn=new Set;function un(t,e){let i=cn.get(t);return i||(i=e(),cn.set(t,i),dn.add(i)),i}const fn=(t,e,i)=>{const s=D(e,i);void 0!==s&&t.add(s)};class gn{constructor(t){this._config=function(t){return(t=t||{}).data=hn(t.data),ln(t),t}(t),this._scopeCache=new Map,this._resolverCache=new Map}get platform(){return this._config.platform}get type(){return this._config.type}set type(t){this._config.type=t}get data(){return this._config.data}set data(t){this._config.data=hn(t)}get options(){return this._config.options}set options(t){this._config.options=t}get plugins(){return this._config.plugins}update(){const t=this._config;this.clearCache(),ln(t)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(t){return un(t,(()=>[[`datasets.${t}`,""]]))}datasetAnimationScopeKeys(t,e){return un(`${t}.transition.${e}`,(()=>[[`datasets.${t}.transitions.${e}`,`transitions.${e}`],[`datasets.${t}`,""]]))}datasetElementScopeKeys(t,e){return un(`${t}-${e}`,(()=>[[`datasets.${t}.elements.${e}`,`datasets.${t}`,`elements.${e}`,""]]))}pluginScopeKeys(t){const e=t.id;return un(`${this.type}-plugin-${e}`,(()=>[[`plugins.${e}`,...t.additionalOptionScopes||[]]]))}_cachedScopes(t,e){const i=this._scopeCache;let s=i.get(t);return s&&!e||(s=new Map,i.set(t,s)),s}getOptionScopes(t,e,i){const{options:s,type:n}=this,o=this._cachedScopes(t,i),a=o.get(e);if(a)return a;const r=new Set;e.forEach((e=>{t&&(r.add(t),e.forEach((e=>fn(r,t,e)))),e.forEach((t=>fn(r,s,t))),e.forEach((t=>fn(r,Xt[n]||{},t))),e.forEach((t=>fn(r,Jt,t))),e.forEach((t=>fn(r,Ut,t)))}));const l=Array.from(r);return 0===l.length&&l.push(Object.create(null)),dn.has(e)&&o.set(e,l),l}chartOptionScopes(){const{options:t,type:e}=this;return[t,Xt[e]||{},Jt.datasets[e]||{},{type:e},Jt,Ut]}resolveNamedOptions(t,e,i,s=[""]){const n={$shared:!0},{resolver:o,subPrefixes:a}=pn(this._resolverCache,t,s);let r=o;if(function(t,e){const{isScriptable:i,isIndexable:s}=Ae(t);for(const n of e){const e=i(n),o=s(n),a=(o||e)&&t[n];if(e&&(A(a)||mn(a))||o&&d(a))return!0}return!1}(o,e)){n.$shared=!1;r=Oe(o,i=A(i)?i():i,this.createResolver(t,i,a))}for(const t of e)n[t]=r[t];return n}createResolver(t,e,i=[""],s){const{resolver:n}=pn(this._resolverCache,t,i);return u(e)?Oe(n,e,void 0,s):n}}function pn(t,e,i){let s=t.get(e);s||(s=new Map,t.set(e,s));const n=i.join();let o=s.get(n);if(!o){o={resolver:Ce(e,i),subPrefixes:i.filter((t=>!t.toLowerCase().includes("hover")))},s.set(n,o)}return o}const mn=t=>u(t)&&Object.getOwnPropertyNames(t).reduce(((e,i)=>e||A(t[i])),!1);const xn=["top","bottom","left","right","chartArea"];function bn(t,e){return"top"===t||"bottom"===t||-1===xn.indexOf(t)&&"x"===e}function yn(t,e){return function(i,s){return i[t]===s[t]?i[e]-s[e]:i[t]-s[t]}}function _n(t){const e=t.chart,i=e.options.animation;e.notifyPlugins("afterRender"),x(i&&i.onComplete,[t],e)}function vn(t){const e=t.chart,i=e.options.animation;x(i&&i.onProgress,[t],e)}function wn(t){return Ke()&&"string"==typeof t?t=document.getElementById(t):t&&t.length&&(t=t[0]),t&&t.canvas&&(t=t.canvas),t}const Mn={},kn=t=>{const e=wn(t);return Object.values(Mn).filter((t=>t.canvas===e)).pop()};function Sn(t,e,i){const s=Object.keys(t);for(const n of s){const s=+n;if(s>=e){const o=t[n];delete t[n],(i>0||s>e)&&(t[s+i]=o)}}}class Pn{constructor(t,e){const i=this.config=new gn(e),s=wn(t),o=kn(s);if(o)throw new Error("Canvas is already in use. Chart with ID '"+o.id+"' must be destroyed before the canvas can be reused.");const a=i.createResolver(i.chartOptionScopes(),this.getContext());this.platform=new(i.platform||function(t){return!Ke()||"undefined"!=typeof OffscreenCanvas&&t instanceof OffscreenCanvas?Ds:Bs}(s)),this.platform.updateConfig(i);const r=this.platform.acquireContext(s,a.aspectRatio),l=r&&r.canvas,c=l&&l.height,d=l&&l.width;this.id=h(),this.ctx=r,this.canvas=l,this.width=d,this.height=c,this._options=a,this._aspectRatio=this.aspectRatio,this._layers=[],this._metasets=[],this._stacks=void 0,this.boxes=[],this.currentDevicePixelRatio=void 0,this.chartArea=void 0,this._active=[],this._lastEvent=void 0,this._listeners={},this._responsiveListeners=void 0,this._sortedMetasets=[],this.scales={},this._plugins=new sn,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=n((t=>this.update(t)),a.resizeDelay||0),this._dataChanges=[],Mn[this.id]=this,r&&l?(Mi.listen(this,"complete",_n),Mi.listen(this,"progress",vn),this._initialize(),this.attached&&this.update()):console.error("Failed to create chart: can't acquire context from the given item")}get aspectRatio(){const{options:{aspectRatio:t,maintainAspectRatio:e},width:i,height:s,_aspectRatio:n}=this;return c(t)?e&&n?n:s?i/s:null:t}get data(){return this.config.data}set data(t){this.config.data=t}get options(){return this._options}set options(t){this.config.options=t}_initialize(){return this.notifyPlugins("beforeInit"),this.options.responsive?this.resize():ni(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins("afterInit"),this}clear(){return te(this.canvas,this.ctx),this}stop(){return Mi.stop(this),this}resize(t,e){Mi.running(this)?this._resizeBeforeDraw={width:t,height:e}:this._resize(t,e)}_resize(t,e){const i=this.options,s=this.canvas,n=i.maintainAspectRatio&&this.aspectRatio,o=this.platform.getMaximumSize(s,t,e,n),a=i.devicePixelRatio||this.platform.getDevicePixelRatio(),r=this.width?"resize":"attach";this.width=o.width,this.height=o.height,this._aspectRatio=this.aspectRatio,ni(this,a,!0)&&(this.notifyPlugins("resize",{size:o}),x(i.onResize,[this,o],this),this.attached&&this._doResize(r)&&this.render())}ensureScalesHaveIDs(){b(this.options.scales||{},((t,e)=>{t.id=e}))}buildOrUpdateScales(){const t=this.options,e=t.scales,i=this.scales,s=Object.keys(i).reduce(((t,e)=>(t[e]=!1,t)),{});let n=[];e&&(n=n.concat(Object.keys(e).map((t=>{const i=e[t],s=rn(t,i),n="r"===s,o="x"===s;return{options:i,dposition:n?"chartArea":o?"bottom":"left",dtype:n?"radialLinear":o?"category":"linear"}})))),b(n,(e=>{const n=e.options,o=n.id,a=rn(o,n),r=p(n.type,e.dtype);void 0!==n.position&&bn(n.position,a)===bn(e.dposition)||(n.position=e.dposition),s[o]=!0;let l=null;if(o in i&&i[o].type===r)l=i[o];else{l=new(en.getScale(r))({id:o,type:r,ctx:this.ctx,chart:this}),i[l.id]=l}l.init(n,t)})),b(s,((t,e)=>{t||delete i[e]})),b(i,(t=>{Ss.configure(this,t,t.options),Ss.addBox(this,t)}))}_updateMetasets(){const t=this._metasets,e=this.data.datasets.length,i=t.length;if(t.sort(((t,e)=>t.index-e.index)),i>e){for(let t=e;te.length&&delete this._stacks,t.forEach(((t,i)=>{0===e.filter((e=>e===t._dataset)).length&&this._destroyDatasetMeta(i)}))}buildOrUpdateControllers(){const t=[],e=this.data.datasets;let i,s;for(this._removeUnreferencedMetasets(),i=0,s=e.length;i{this.getDatasetMeta(e).controller.reset()}),this)}reset(){this._resetElements(),this.notifyPlugins("reset")}update(t){const e=this.config;e.update();const i=this._options=e.createResolver(e.chartOptionScopes(),this.getContext()),s=this._animationsDisabled=!i.animation;if(this._updateScales(),this._checkEventBindings(),this._updateHiddenIndices(),this._plugins.invalidate(),!1===this.notifyPlugins("beforeUpdate",{mode:t,cancelable:!0}))return;const n=this.buildOrUpdateControllers();this.notifyPlugins("beforeElementsUpdate");let o=0;for(let t=0,e=this.data.datasets.length;t{t.reset()})),this._updateDatasets(t),this.notifyPlugins("afterUpdate",{mode:t}),this._layers.sort(yn("z","_idx"));const{_active:a,_lastEvent:r}=this;r?this._eventHandler(r,!0):a.length&&this._updateHoverStyles(a,a,!0),this.render()}_updateScales(){b(this.scales,(t=>{Ss.removeBox(this,t)})),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){const t=this.options,e=new Set(Object.keys(this._listeners)),i=new Set(t.events);T(e,i)&&!!this._responsiveListeners===t.responsive||(this.unbindEvents(),this.bindEvents())}_updateHiddenIndices(){const{_hiddenIndices:t}=this,e=this._getUniformDataChanges()||[];for(const{method:i,start:s,count:n}of e){Sn(t,s,"_removeElements"===i?-n:n)}}_getUniformDataChanges(){const t=this._dataChanges;if(!t||!t.length)return;this._dataChanges=[];const e=this.data.datasets.length,i=e=>new Set(t.filter((t=>t[0]===e)).map(((t,e)=>e+","+t.splice(1).join(",")))),s=i(0);for(let t=1;tt.split(","))).map((t=>({method:t[1],start:+t[2],count:+t[3]})))}_updateLayout(t){if(!1===this.notifyPlugins("beforeLayout",{cancelable:!0}))return;Ss.update(this,this.width,this.height,t);const e=this.chartArea,i=e.width<=0||e.height<=0;this._layers=[],b(this.boxes,(t=>{i&&"chartArea"===t.position||(t.configure&&t.configure(),this._layers.push(...t._layers()))}),this),this._layers.forEach(((t,e)=>{t._idx=e})),this.notifyPlugins("afterLayout")}_updateDatasets(t){if(!1!==this.notifyPlugins("beforeDatasetsUpdate",{mode:t,cancelable:!0})){for(let t=0,e=this.data.datasets.length;t=0;--e)this._drawDataset(t[e]);this.notifyPlugins("afterDatasetsDraw")}_drawDataset(t){const e=this.ctx,i=t._clip,s=!i.disabled,n=this.chartArea,o={meta:t,index:t.index,cancelable:!0};!1!==this.notifyPlugins("beforeDatasetDraw",o)&&(s&&se(e,{left:!1===i.left?0:n.left-i.left,right:!1===i.right?this.width:n.right+i.right,top:!1===i.top?0:n.top-i.top,bottom:!1===i.bottom?this.height:n.bottom+i.bottom}),t.controller.draw(),s&&ne(e),o.cancelable=!1,this.notifyPlugins("afterDatasetDraw",o))}isPointInArea(t){return ie(t,this.chartArea,this._minPadding)}getElementsAtEventForMode(t,e,i,s){const n=us.modes[e];return"function"==typeof n?n(this,t,i,s):[]}getDatasetMeta(t){const e=this.data.datasets[t],i=this._metasets;let s=i.filter((t=>t&&t._dataset===e)).pop();return s||(s={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:e&&e.order||0,index:t,_dataset:e,_parsed:[],_sorted:!1},i.push(s)),s}getContext(){return this.$context||(this.$context=_e(null,{chart:this,type:"chart"}))}getVisibleDatasetCount(){return this.getSortedVisibleDatasetMetas().length}isDatasetVisible(t){const e=this.data.datasets[t];if(!e)return!1;const i=this.getDatasetMeta(t);return"boolean"==typeof i.hidden?!i.hidden:!e.hidden}setDatasetVisibility(t,e){this.getDatasetMeta(t).hidden=!e}toggleDataVisibility(t){this._hiddenIndices[t]=!this._hiddenIndices[t]}getDataVisibility(t){return!this._hiddenIndices[t]}_updateVisibility(t,e,i){const s=i?"show":"hide",n=this.getDatasetMeta(t),o=n.controller._resolveAnimations(void 0,s);O(e)?(n.data[e].hidden=!i,this.update()):(this.setDatasetVisibility(t,i),o.update(n,{visible:i}),this.update((e=>e.datasetIndex===t?s:void 0)))}hide(t,e){this._updateVisibility(t,e,!1)}show(t,e){this._updateVisibility(t,e,!0)}_destroyDatasetMeta(t){const e=this._metasets[t];e&&e.controller&&e.controller._destroy(),delete this._metasets[t]}_stop(){let t,e;for(this.stop(),Mi.remove(this),t=0,e=this.data.datasets.length;t{e.addEventListener(this,i,s),t[i]=s},s=(t,e,i)=>{t.offsetX=e,t.offsetY=i,this._eventHandler(t)};b(this.options.events,(t=>i(t,s)))}bindResponsiveEvents(){this._responsiveListeners||(this._responsiveListeners={});const t=this._responsiveListeners,e=this.platform,i=(i,s)=>{e.addEventListener(this,i,s),t[i]=s},s=(i,s)=>{t[i]&&(e.removeEventListener(this,i,s),delete t[i])},n=(t,e)=>{this.canvas&&this.resize(t,e)};let o;const a=()=>{s("attach",a),this.attached=!0,this.resize(),i("resize",n),i("detach",o)};o=()=>{this.attached=!1,s("resize",n),this._stop(),this._resize(0,0),i("attach",a)},e.isAttached(this.canvas)?a():o()}unbindEvents(){b(this._listeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._listeners={},b(this._responsiveListeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._responsiveListeners=void 0}updateHoverStyle(t,e,i){const s=i?"set":"remove";let n,o,a,r;for("dataset"===e&&(n=this.getDatasetMeta(t[0].datasetIndex),n.controller["_"+s+"DatasetHoverStyle"]()),a=0,r=t.length;a{const i=this.getDatasetMeta(t);if(!i)throw new Error("No dataset found at index "+t);return{datasetIndex:t,element:i.data[e],index:e}}));!y(i,e)&&(this._active=i,this._lastEvent=null,this._updateHoverStyles(i,e))}notifyPlugins(t,e,i){return this._plugins.notify(this,t,e,i)}_updateHoverStyles(t,e,i){const s=this.options.hover,n=(t,e)=>t.filter((t=>!e.some((e=>t.datasetIndex===e.datasetIndex&&t.index===e.index)))),o=n(e,t),a=i?t:n(t,e);o.length&&this.updateHoverStyle(o,s.mode,!1),a.length&&s.mode&&this.updateHoverStyle(a,s.mode,!0)}_eventHandler(t,e){const i={event:t,replay:e,cancelable:!0,inChartArea:this.isPointInArea(t)},s=e=>(e.options.events||this.options.events).includes(t.native.type);if(!1===this.notifyPlugins("beforeEvent",i,s))return;const n=this._handleEvent(t,e,i.inChartArea);return i.cancelable=!1,this.notifyPlugins("afterEvent",i,s),(n||i.changed)&&this.render(),this}_handleEvent(t,e,i){const{_active:s=[],options:n}=this,o=e,a=this._getActiveElements(t,s,i,o),r=R(t),l=function(t,e,i,s){return i&&"mouseout"!==t.type?s?e:t:null}(t,this._lastEvent,i,r);i&&(this._lastEvent=null,x(n.onHover,[t,a,this],this),r&&x(n.onClick,[t,a,this],this));const h=!y(a,s);return(h||e)&&(this._active=a,this._updateHoverStyles(a,s,e)),this._lastEvent=l,h}_getActiveElements(t,e,i,s){if("mouseout"===t.type)return[];if(!i)return e;const n=this.options.hover;return this.getElementsAtEventForMode(t,n.mode,n,s)}}const Dn=()=>b(Pn.instances,(t=>t._plugins.invalidate()));function Cn(t,e,i){const{startAngle:s,pixelMargin:n,x:o,y:a,outerRadius:r,innerRadius:l}=e;let h=n/r;t.beginPath(),t.arc(o,a,r,s-h,i+h),l>n?(h=n/l,t.arc(o,a,l,i+h,s-h,!0)):t.arc(o,a,n,i+W,s-W),t.closePath(),t.clip()}function On(t,e,i,s){const n=fe(t.options.borderRadius,["outerStart","outerEnd","innerStart","innerEnd"]);const o=(i-e)/2,a=Math.min(o,s*e/2),r=t=>{const e=(i-Math.min(o,t))*s/2;return st(t,0,Math.min(o,e))};return{outerStart:r(n.outerStart),outerEnd:r(n.outerEnd),innerStart:st(n.innerStart,0,a),innerEnd:st(n.innerEnd,0,a)}}function An(t,e,i,s){return{x:i+t*Math.cos(e),y:s+t*Math.sin(e)}}function Tn(t,e,i,s,n){const{x:o,y:a,startAngle:r,pixelMargin:l,innerRadius:h}=e,c=Math.max(e.outerRadius+s+i-l,0),d=h>0?h+s+i+l:0;let u=0;const f=n-r;if(s){const t=((h>0?h-s:0)+(c>0?c-s:0))/2;u=(f-(0!==t?f*t/(t+s):f))/2}const g=(f-Math.max(.001,f*c-i/L)/c)/2,p=r+g+u,m=n-g-u,{outerStart:x,outerEnd:b,innerStart:y,innerEnd:_}=On(e,d,c,m-p),v=c-x,w=c-b,M=p+x/v,k=m-b/w,S=d+y,P=d+_,D=p+y/S,C=m-_/P;if(t.beginPath(),t.arc(o,a,c,M,k),b>0){const e=An(w,k,o,a);t.arc(e.x,e.y,b,k,m+W)}const O=An(P,m,o,a);if(t.lineTo(O.x,O.y),_>0){const e=An(P,C,o,a);t.arc(e.x,e.y,_,m+W,C+Math.PI)}if(t.arc(o,a,d,m-_/d,p+y/d,!0),y>0){const e=An(S,D,o,a);t.arc(e.x,e.y,y,D+Math.PI,p-W)}const A=An(v,p,o,a);if(t.lineTo(A.x,A.y),x>0){const e=An(v,M,o,a);t.arc(e.x,e.y,x,p-W,M)}t.closePath()}function Rn(t,e,i,s,n){const{options:o}=e,{borderWidth:a,borderJoinStyle:r}=o,l="inner"===o.borderAlign;a&&(l?(t.lineWidth=2*a,t.lineJoin=r||"round"):(t.lineWidth=a,t.lineJoin=r||"bevel"),e.fullCircles&&function(t,e,i){const{x:s,y:n,startAngle:o,pixelMargin:a,fullCircles:r}=e,l=Math.max(e.outerRadius-a,0),h=e.innerRadius+a;let c;for(i&&Cn(t,e,o+E),t.beginPath(),t.arc(s,n,h,o+E,o,!0),c=0;c{en.add(...t),Dn()}},unregister:{enumerable:true,value:(...t)=>{en.remove(...t),Dn()}}});class Ln extends Ns{constructor(t){super(),this.options=void 0,this.circumference=void 0,this.startAngle=void 0,this.endAngle=void 0,this.innerRadius=void 0,this.outerRadius=void 0,this.pixelMargin=0,this.fullCircles=0,t&&Object.assign(this,t)}inRange(t,e,i){const s=this.getProps(["x","y"],i),{angle:n,distance:o}=Z(s,{x:t,y:e}),{startAngle:a,endAngle:r,innerRadius:l,outerRadius:h,circumference:c}=this.getProps(["startAngle","endAngle","innerRadius","outerRadius","circumference"],i),d=this.options.spacing/2,u=p(c,r-a)>=E||it(n,a,r),f=nt(o,l+d,h+d);return u&&f}getCenterPoint(t){const{x:e,y:i,startAngle:s,endAngle:n,innerRadius:o,outerRadius:a}=this.getProps(["x","y","startAngle","endAngle","innerRadius","outerRadius","circumference"],t),{offset:r,spacing:l}=this.options,h=(s+n)/2,c=(o+a+l+r)/2;return{x:e+Math.cos(h)*c,y:i+Math.sin(h)*c}}tooltipPosition(t){return this.getCenterPoint(t)}draw(t){const{options:e,circumference:i}=this,s=(e.offset||0)/2,n=(e.spacing||0)/2;if(this.pixelMargin="inner"===e.borderAlign?.33:0,this.fullCircles=i>E?Math.floor(i/E):0,0===i||this.innerRadius<0||this.outerRadius<0)return;t.save();let o=0;if(s){o=s/2;const e=(this.startAngle+this.endAngle)/2;t.translate(Math.cos(e)*o,Math.sin(e)*o),this.circumference>=L&&(o=s)}t.fillStyle=e.backgroundColor,t.strokeStyle=e.borderColor;const a=function(t,e,i,s){const{fullCircles:n,startAngle:o,circumference:a}=e;let r=e.endAngle;if(n){Tn(t,e,i,s,o+E);for(let e=0;er&&o>r;return{count:s,start:l,loop:e.loop,ilen:h(a+(h?r-t:t))%o,y=()=>{f!==g&&(t.lineTo(m,g),t.lineTo(m,f),t.lineTo(m,p))};for(l&&(d=n[b(0)],t.moveTo(d.x,d.y)),c=0;c<=r;++c){if(d=n[b(c)],d.skip)continue;const e=d.x,i=d.y,s=0|e;s===u?(ig&&(g=i),m=(x*m+e)/++x):(y(),t.lineTo(e,i),u=s,x=0,f=g=i),p=i}y()}function Vn(t){const e=t.options,i=e.borderDash&&e.borderDash.length;return!(t._decimated||t._loop||e.tension||"monotone"===e.cubicInterpolationMode||e.stepped||i)?Wn:Fn}Ln.id="arc",Ln.defaults={borderAlign:"center",borderColor:"#fff",borderJoinStyle:void 0,borderRadius:0,borderWidth:2,offset:0,spacing:0,angle:void 0},Ln.defaultRoutes={backgroundColor:"backgroundColor"};const jn="function"==typeof Path2D;function Bn(t,e,i,s){jn&&!e.options.segment?function(t,e,i,s){let n=e._path;n||(n=e._path=new Path2D,e.path(n,i,s)&&n.closePath()),En(t,e.options),t.stroke(n)}(t,e,i,s):function(t,e,i,s){const{segments:n,options:o}=e,a=Vn(e);for(const r of n)En(t,o,r.style),t.beginPath(),a(t,e,r,{start:i,end:i+s-1})&&t.closePath(),t.stroke()}(t,e,i,s)}class Nn extends Ns{constructor(t){super(),this.animated=!0,this.options=void 0,this._chart=void 0,this._loop=void 0,this._fullLoop=void 0,this._path=void 0,this._points=void 0,this._segments=void 0,this._decimated=!1,this._pointsUpdated=!1,this._datasetIndex=void 0,t&&Object.assign(this,t)}updateControlPoints(t,e){const i=this.options;if((i.tension||"monotone"===i.cubicInterpolationMode)&&!i.stepped&&!this._pointsUpdated){const s=i.spanGaps?this._loop:this._fullLoop;qe(this._points,i,t,s,e),this._pointsUpdated=!0}}set points(t){this._points=t,delete this._segments,delete this._path,this._pointsUpdated=!1}get points(){return this._points}get segments(){return this._segments||(this._segments=yi(this,this.options.segment))}first(){const t=this.segments,e=this.points;return t.length&&e[t[0].start]}last(){const t=this.segments,e=this.points,i=t.length;return i&&e[t[i-1].end]}interpolate(t,e){const i=this.options,s=t[e],n=this.points,o=bi(this,{property:e,start:s,end:s});if(!o.length)return;const a=[],r=function(t){return t.stepped?li:t.tension||"monotone"===t.cubicInterpolationMode?hi:ri}(i);let l,h;for(l=0,h=o.length;l"borderDash"!==t&&"fill"!==t};class $n extends Ns{constructor(t){super(),this.options=void 0,this.parsed=void 0,this.skip=void 0,this.stop=void 0,t&&Object.assign(this,t)}inRange(t,e,i){const s=this.options,{x:n,y:o}=this.getProps(["x","y"],i);return Math.pow(t-n,2)+Math.pow(e-o,2){Qn(t)}))}var eo={id:"decimation",defaults:{algorithm:"min-max",enabled:!1},beforeElementsUpdate:(t,e,i)=>{if(!i.enabled)return void to(t);const s=t.width;t.data.datasets.forEach(((e,n)=>{const{_data:o,indexAxis:a}=e,r=t.getDatasetMeta(n),l=o||e.data;if("y"===be([a,t.options.indexAxis]))return;if(!r.controller.supportsDecimation)return;const h=t.scales[r.xAxisID];if("linear"!==h.type&&"time"!==h.type)return;if(t.options.parsing)return;let{start:d,count:u}=function(t,e){const i=e.length;let s,n=0;const{iScale:o}=t,{min:a,max:r,minDefined:l,maxDefined:h}=o.getUserBounds();return l&&(n=st(we(e,o.axis,a).lo,0,i-1)),s=h?st(we(e,o.axis,r).hi+1,n,i)-n:i-n,{start:n,count:s}}(r,l);if(u<=(i.threshold||4*s))return void Qn(e);let f;switch(c(o)&&(e._data=l,delete e.data,Object.defineProperty(e,"data",{configurable:!0,enumerable:!0,get:function(){return this._decimated},set:function(t){this._data=t}})),i.algorithm){case"lttb":f=function(t,e,i,s,n){const o=n.samples||s;if(o>=i)return t.slice(e,e+i);const a=[],r=(i-2)/(o-2);let l=0;const h=e+i-1;let c,d,u,f,g,p=e;for(a[l++]=t[p],c=0;cu&&(u=f,d=t[s],g=s);a[l++]=d,p=g}return a[l++]=t[h],a}(l,d,u,s,i);break;case"min-max":f=function(t,e,i,s){let n,o,a,r,l,h,d,u,f,g,p=0,m=0;const x=[],b=e+i-1,y=t[e].x,_=t[b].x-y;for(n=e;ng&&(g=r,d=n),p=(m*p+o.x)/++m;else{const i=n-1;if(!c(h)&&!c(d)){const e=Math.min(h,d),s=Math.max(h,d);e!==u&&e!==i&&x.push({...t[e],x:p}),s!==u&&s!==i&&x.push({...t[s],x:p})}n>0&&i!==u&&x.push(t[i]),x.push(o),l=e,m=0,f=g=r,h=d=u=n}}return x}(l,d,u,s);break;default:throw new Error(`Unsupported decimation algorithm '${i.algorithm}'`)}e._decimated=f}))},destroy(t){to(t)}};function io(t,e,i,s){if(s)return;let n=e[t],o=i[t];return"angle"===t&&(n=et(n),o=et(o)),{property:t,start:n,end:o}}function so(t,e,i){for(;e>t;e--){const t=i[e];if(!isNaN(t.x)&&!isNaN(t.y))break}return e}function no(t,e,i,s){return t&&e?s(t[i],e[i]):t?t[i]:e?e[i]:0}function oo(t,e){let i=[],s=!1;return d(t)?(s=!0,i=t):i=function(t,e){const{x:i=null,y:s=null}=t||{},n=e.points,o=[];return e.segments.forEach((({start:t,end:e})=>{e=so(t,e,n);const a=n[t],r=n[e];null!==s?(o.push({x:a.x,y:s}),o.push({x:r.x,y:s})):null!==i&&(o.push({x:i,y:a.y}),o.push({x:i,y:r.y}))})),o}(t,e),i.length?new Nn({points:i,options:{tension:0},_loop:s,_fullLoop:s}):null}function ao(t,e,i){let s=t[e].fill;const n=[e];let o;if(!i)return s;for(;!1!==s&&-1===n.indexOf(s);){if(!f(s))return s;if(o=t[s],!o)return!1;if(o.visible)return s;n.push(s),s=o.fill}return!1}function ro(t,e,i){const s=function(t){const e=t.options,i=e.fill;let s=p(i&&i.target,i);void 0===s&&(s=!!e.backgroundColor);return!1!==s&&null!==s&&(!0===s?"origin":s)}(t);if(u(s))return!isNaN(s.value)&&s;let n=parseFloat(s);return f(n)&&Math.floor(n)===n?function(t,e,i,s){"-"!==t&&"+"!==t||(i=e+i);return!(i===e||i<0||i>=s)&&i}(s[0],e,n,i):["origin","start","end","stack","shape"].indexOf(s)>=0&&s}function lo(t,e,i){const s=[];for(let n=0;n=0;--e){const i=n[e].$filler;i&&(i.line.updateControlPoints(o,i.axis),s&&fo(t.ctx,i,o))}},beforeDatasetsDraw(t,e,i){if("beforeDatasetsDraw"!==i.drawTime)return;const s=t.getSortedVisibleDatasetMetas();for(let e=s.length-1;e>=0;--e){const i=s[e].$filler;i&&fo(t.ctx,i,t.chartArea)}},beforeDatasetDraw(t,e,i){const s=e.meta.$filler;s&&!1!==s.fill&&"beforeDatasetDraw"===i.drawTime&&fo(t.ctx,s,t.chartArea)},defaults:{propagate:!0,drawTime:"beforeDatasetDraw"}};const yo=(t,e)=>{let{boxHeight:i=e,boxWidth:s=e}=t;return t.usePointStyle&&(i=Math.min(i,e),s=Math.min(s,e)),{boxWidth:s,boxHeight:i,itemHeight:Math.max(e,i)}};class _o extends Ns{constructor(t){super(),this._added=!1,this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1,this.chart=t.chart,this.options=t.options,this.ctx=t.ctx,this.legendItems=void 0,this.columnSizes=void 0,this.lineWidths=void 0,this.maxHeight=void 0,this.maxWidth=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.height=void 0,this.width=void 0,this._margins=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(t,e,i){this.maxWidth=t,this.maxHeight=e,this._margins=i,this.setDimensions(),this.buildLabels(),this.fit()}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=this._margins.left,this.right=this.width):(this.height=this.maxHeight,this.top=this._margins.top,this.bottom=this.height)}buildLabels(){const t=this.options.labels||{};let e=x(t.generateLabels,[this.chart],this)||[];t.filter&&(e=e.filter((e=>t.filter(e,this.chart.data)))),t.sort&&(e=e.sort(((e,i)=>t.sort(e,i,this.chart.data)))),this.options.reverse&&e.reverse(),this.legendItems=e}fit(){const{options:t,ctx:e}=this;if(!t.display)return void(this.width=this.height=0);const i=t.labels,s=xe(i.font),n=s.size,o=this._computeTitleHeight(),{boxWidth:a,itemHeight:r}=yo(i,n);let l,h;e.font=s.string,this.isHorizontal()?(l=this.maxWidth,h=this._fitRows(o,n,a,r)+10):(h=this.maxHeight,l=this._fitCols(o,n,a,r)+10),this.width=Math.min(l,t.maxWidth||this.maxWidth),this.height=Math.min(h,t.maxHeight||this.maxHeight)}_fitRows(t,e,i,s){const{ctx:n,maxWidth:o,options:{labels:{padding:a}}}=this,r=this.legendHitBoxes=[],l=this.lineWidths=[0],h=s+a;let c=t;n.textAlign="left",n.textBaseline="middle";let d=-1,u=-h;return this.legendItems.forEach(((t,f)=>{const g=i+e/2+n.measureText(t.text).width;(0===f||l[l.length-1]+g+2*a>o)&&(c+=h,l[l.length-(f>0?0:1)]=0,u+=h,d++),r[f]={left:0,top:u,row:d,width:g,height:s},l[l.length-1]+=g+a})),c}_fitCols(t,e,i,s){const{ctx:n,maxHeight:o,options:{labels:{padding:a}}}=this,r=this.legendHitBoxes=[],l=this.columnSizes=[],h=o-t;let c=a,d=0,u=0,f=0,g=0;return this.legendItems.forEach(((t,o)=>{const p=i+e/2+n.measureText(t.text).width;o>0&&u+s+2*a>h&&(c+=d+a,l.push({width:d,height:u}),f+=d+a,g++,d=u=0),r[o]={left:f,top:u,col:g,width:p,height:s},d=Math.max(d,p),u+=s+a})),c+=d,l.push({width:d,height:u}),c}adjustHitBoxes(){if(!this.options.display)return;const t=this._computeTitleHeight(),{legendHitBoxes:e,options:{align:i,labels:{padding:s},rtl:n}}=this,o=ui(n,this.left,this.width);if(this.isHorizontal()){let n=0,r=a(i,this.left+s,this.right-this.lineWidths[n]);for(const l of e)n!==l.row&&(n=l.row,r=a(i,this.left+s,this.right-this.lineWidths[n])),l.top+=this.top+t+s,l.left=o.leftForLtr(o.x(r),l.width),r+=l.width+s}else{let n=0,r=a(i,this.top+t+s,this.bottom-this.columnSizes[n].height);for(const l of e)l.col!==n&&(n=l.col,r=a(i,this.top+t+s,this.bottom-this.columnSizes[n].height)),l.top=r,l.left+=this.left+s,l.left=o.leftForLtr(o.x(l.left),l.width),r+=l.height+s}}isHorizontal(){return"top"===this.options.position||"bottom"===this.options.position}draw(){if(this.options.display){const t=this.ctx;se(t,this),this._draw(),ne(t)}}_draw(){const{options:t,columnSizes:e,lineWidths:i,ctx:s}=this,{align:n,labels:o}=t,l=Jt.color,h=ui(t.rtl,this.left,this.width),c=xe(o.font),{color:d,padding:u}=o,f=c.size,g=f/2;let m;this.drawTitle(),s.textAlign=h.textAlign("left"),s.textBaseline="middle",s.lineWidth=.5,s.font=c.string;const{boxWidth:x,boxHeight:b,itemHeight:y}=yo(o,f),_=this.isHorizontal(),v=this._computeTitleHeight();m=_?{x:a(n,this.left+u,this.right-i[0]),y:this.top+u+v,line:0}:{x:this.left+u,y:a(n,this.top+v+u,this.bottom-e[0].height),line:0},fi(this.ctx,t.textDirection);const w=y+u;this.legendItems.forEach(((M,k)=>{s.strokeStyle=M.fontColor||d,s.fillStyle=M.fontColor||d;const S=s.measureText(M.text).width,P=h.textAlign(M.textAlign||(M.textAlign=o.textAlign)),D=x+g+S;let C=m.x,O=m.y;h.setWidth(this.width),_?k>0&&C+D+u>this.right&&(O=m.y+=w,m.line++,C=m.x=a(n,this.left+u,this.right-i[m.line])):k>0&&O+w>this.bottom&&(C=m.x=C+e[m.line].width+u,m.line++,O=m.y=a(n,this.top+v+u,this.bottom-e[m.line].height));!function(t,e,i){if(isNaN(x)||x<=0||isNaN(b)||b<0)return;s.save();const n=p(i.lineWidth,1);if(s.fillStyle=p(i.fillStyle,l),s.lineCap=p(i.lineCap,"butt"),s.lineDashOffset=p(i.lineDashOffset,0),s.lineJoin=p(i.lineJoin,"miter"),s.lineWidth=n,s.strokeStyle=p(i.strokeStyle,l),s.setLineDash(p(i.lineDash,[])),o.usePointStyle){const o={radius:x*Math.SQRT2/2,pointStyle:i.pointStyle,rotation:i.rotation,borderWidth:n},a=h.xPlus(t,x/2);ee(s,o,a,e+g)}else{const o=e+Math.max((f-b)/2,0),a=h.leftForLtr(t,x),r=pe(i.borderRadius);s.beginPath(),Object.values(r).some((t=>0!==t))?he(s,{x:a,y:o,w:x,h:b,radius:r}):s.rect(a,o,x,b),s.fill(),0!==n&&s.stroke()}s.restore()}(h.x(C),O,M),C=r(P,C+x+g,_?C+D:this.right,t.rtl),function(t,e,i){re(s,i.text,t,e+y/2,c,{strikethrough:i.hidden,textAlign:h.textAlign(i.textAlign)})}(h.x(C),O,M),_?m.x+=D+u:m.y+=w})),gi(this.ctx,t.textDirection)}drawTitle(){const t=this.options,e=t.title,i=xe(e.font),s=me(e.padding);if(!e.display)return;const n=ui(t.rtl,this.left,this.width),r=this.ctx,l=e.position,h=i.size/2,c=s.top+h;let d,u=this.left,f=this.width;if(this.isHorizontal())f=Math.max(...this.lineWidths),d=this.top+c,u=a(t.align,u,this.right-f);else{const e=this.columnSizes.reduce(((t,e)=>Math.max(t,e.height)),0);d=c+a(t.align,this.top,this.bottom-e-t.labels.padding-this._computeTitleHeight())}const g=a(l,u,u+f);r.textAlign=n.textAlign(o(l)),r.textBaseline="middle",r.strokeStyle=e.color,r.fillStyle=e.color,r.font=i.string,re(r,e.text,g,d,i)}_computeTitleHeight(){const t=this.options.title,e=xe(t.font),i=me(t.padding);return t.display?e.lineHeight+i.height:0}_getLegendItemAt(t,e){let i,s,n;if(nt(t,this.left,this.right)&&nt(e,this.top,this.bottom))for(n=this.legendHitBoxes,i=0;it.chart.options.color,boxWidth:40,padding:10,generateLabels(t){const e=t.data.datasets,{labels:{usePointStyle:i,pointStyle:s,textAlign:n,color:o}}=t.legend.options;return t._getSortedDatasetMetas().map((t=>{const a=t.controller.getStyle(i?0:void 0),r=me(a.borderWidth);return{text:e[t.index].label,fillStyle:a.backgroundColor,fontColor:o,hidden:!t.visible,lineCap:a.borderCapStyle,lineDash:a.borderDash,lineDashOffset:a.borderDashOffset,lineJoin:a.borderJoinStyle,lineWidth:(r.width+r.height)/4,strokeStyle:a.borderColor,pointStyle:s||a.pointStyle,rotation:a.rotation,textAlign:n||a.textAlign,borderRadius:0,datasetIndex:t.index}}),this)}},title:{color:t=>t.chart.options.color,display:!1,position:"center",text:""}},descriptors:{_scriptable:t=>!t.startsWith("on"),labels:{_scriptable:t=>!["generateLabels","filter","sort"].includes(t)}}};class wo extends Ns{constructor(t){super(),this.chart=t.chart,this.options=t.options,this.ctx=t.ctx,this._padding=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(t,e){const i=this.options;if(this.left=0,this.top=0,!i.display)return void(this.width=this.height=this.right=this.bottom=0);this.width=this.right=t,this.height=this.bottom=e;const s=d(i.text)?i.text.length:1;this._padding=me(i.padding);const n=s*xe(i.font).lineHeight+this._padding.height;this.isHorizontal()?this.height=n:this.width=n}isHorizontal(){const t=this.options.position;return"top"===t||"bottom"===t}_drawArgs(t){const{top:e,left:i,bottom:s,right:n,options:o}=this,r=o.align;let l,h,c,d=0;return this.isHorizontal()?(h=a(r,i,n),c=e+t,l=n-i):("left"===o.position?(h=i+t,c=a(r,s,e),d=-.5*L):(h=n-t,c=a(r,e,s),d=.5*L),l=s-e),{titleX:h,titleY:c,maxWidth:l,rotation:d}}draw(){const t=this.ctx,e=this.options;if(!e.display)return;const i=xe(e.font),s=i.lineHeight/2+this._padding.top,{titleX:n,titleY:a,maxWidth:r,rotation:l}=this._drawArgs(s);re(t,e.text,0,0,i,{color:e.color,maxWidth:r,rotation:l,textAlign:o(e.align),textBaseline:"middle",translation:[n,a]})}}var Mo={id:"title",_element:wo,start(t,e,i){!function(t,e){const i=new wo({ctx:t.ctx,options:e,chart:t});Ss.configure(t,i,e),Ss.addBox(t,i),t.titleBlock=i}(t,i)},stop(t){const e=t.titleBlock;Ss.removeBox(t,e),delete t.titleBlock},beforeUpdate(t,e,i){const s=t.titleBlock;Ss.configure(t,s,i),s.options=i},defaults:{align:"center",display:!1,font:{weight:"bold"},fullSize:!0,padding:10,position:"top",text:"",weight:2e3},defaultRoutes:{color:"color"},descriptors:{_scriptable:!0,_indexable:!1}};const ko=new WeakMap;var So={id:"subtitle",start(t,e,i){const s=new wo({ctx:t.ctx,options:i,chart:t});Ss.configure(t,s,i),Ss.addBox(t,s),ko.set(t,s)},stop(t){Ss.removeBox(t,ko.get(t)),ko.delete(t)},beforeUpdate(t,e,i){const s=ko.get(t);Ss.configure(t,s,i),s.options=i},defaults:{align:"center",display:!1,font:{weight:"normal"},fullSize:!0,padding:0,position:"top",text:"",weight:1500},defaultRoutes:{color:"color"},descriptors:{_scriptable:!0,_indexable:!1}};const Po={average(t){if(!t.length)return!1;let e,i,s=0,n=0,o=0;for(e=0,i=t.length;e-1?t.split("\n"):t}function Oo(t,e){const{element:i,datasetIndex:s,index:n}=e,o=t.getDatasetMeta(s).controller,{label:a,value:r}=o.getLabelAndValue(n);return{chart:t,label:a,parsed:o.getParsed(n),raw:t.data.datasets[s].data[n],formattedValue:r,dataset:o.getDataset(),dataIndex:n,datasetIndex:s,element:i}}function Ao(t,e){const i=t.chart.ctx,{body:s,footer:n,title:o}=t,{boxWidth:a,boxHeight:r}=e,l=xe(e.bodyFont),h=xe(e.titleFont),c=xe(e.footerFont),d=o.length,u=n.length,f=s.length,g=me(e.padding);let p=g.height,m=0,x=s.reduce(((t,e)=>t+e.before.length+e.lines.length+e.after.length),0);if(x+=t.beforeBody.length+t.afterBody.length,d&&(p+=d*h.lineHeight+(d-1)*e.titleSpacing+e.titleMarginBottom),x){p+=f*(e.displayColors?Math.max(r,l.lineHeight):l.lineHeight)+(x-f)*l.lineHeight+(x-1)*e.bodySpacing}u&&(p+=e.footerMarginTop+u*c.lineHeight+(u-1)*e.footerSpacing);let y=0;const _=function(t){m=Math.max(m,i.measureText(t).width+y)};return i.save(),i.font=h.string,b(t.title,_),i.font=l.string,b(t.beforeBody.concat(t.afterBody),_),y=e.displayColors?a+2+e.boxPadding:0,b(s,(t=>{b(t.before,_),b(t.lines,_),b(t.after,_)})),y=0,i.font=c.string,b(t.footer,_),i.restore(),m+=g.width,{width:m,height:p}}function To(t,e,i,s){const{x:n,width:o}=i,{width:a,chartArea:{left:r,right:l}}=t;let h="center";return"center"===s?h=n<=(r+l)/2?"left":"right":n<=o/2?h="left":n>=a-o/2&&(h="right"),function(t,e,i,s){const{x:n,width:o}=s,a=i.caretSize+i.caretPadding;return"left"===t&&n+o+a>e.width||"right"===t&&n-o-a<0||void 0}(h,t,e,i)&&(h="center"),h}function Ro(t,e,i){const s=i.yAlign||e.yAlign||function(t,e){const{y:i,height:s}=e;return it.height-s/2?"bottom":"center"}(t,i);return{xAlign:i.xAlign||e.xAlign||To(t,e,i,s),yAlign:s}}function Lo(t,e,i,s){const{caretSize:n,caretPadding:o,cornerRadius:a}=t,{xAlign:r,yAlign:l}=i,h=n+o,{topLeft:c,topRight:d,bottomLeft:u,bottomRight:f}=pe(a);let g=function(t,e){let{x:i,width:s}=t;return"right"===e?i-=s:"center"===e&&(i-=s/2),i}(e,r);const p=function(t,e,i){let{y:s,height:n}=t;return"top"===e?s+=i:s-="bottom"===e?n+i:n/2,s}(e,l,h);return"center"===l?"left"===r?g+=h:"right"===r&&(g-=h):"left"===r?g-=Math.max(c,u)+n:"right"===r&&(g+=Math.max(d,f)+n),{x:st(g,0,s.width-e.width),y:st(p,0,s.height-e.height)}}function Eo(t,e,i){const s=me(i.padding);return"center"===e?t.x+t.width/2:"right"===e?t.x+t.width-s.right:t.x+s.left}function Io(t){return Do([],Co(t))}function zo(t,e){const i=e&&e.dataset&&e.dataset.tooltip&&e.dataset.tooltip.callbacks;return i?t.override(i):t}class Fo extends Ns{constructor(t){super(),this.opacity=0,this._active=[],this._eventPosition=void 0,this._size=void 0,this._cachedAnimations=void 0,this._tooltipItems=[],this.$animations=void 0,this.$context=void 0,this.chart=t.chart||t._chart,this._chart=this.chart,this.options=t.options,this.dataPoints=void 0,this.title=void 0,this.beforeBody=void 0,this.body=void 0,this.afterBody=void 0,this.footer=void 0,this.xAlign=void 0,this.yAlign=void 0,this.x=void 0,this.y=void 0,this.height=void 0,this.width=void 0,this.caretX=void 0,this.caretY=void 0,this.labelColors=void 0,this.labelPointStyles=void 0,this.labelTextColors=void 0}initialize(t){this.options=t,this._cachedAnimations=void 0,this.$context=void 0}_resolveAnimations(){const t=this._cachedAnimations;if(t)return t;const e=this.chart,i=this.options.setContext(this.getContext()),s=i.enabled&&e.options.animation&&i.animations,n=new Di(this.chart,s);return s._cacheable&&(this._cachedAnimations=Object.freeze(n)),n}getContext(){return this.$context||(this.$context=(t=this.chart.getContext(),e=this,i=this._tooltipItems,_e(t,{tooltip:e,tooltipItems:i,type:"tooltip"})));var t,e,i}getTitle(t,e){const{callbacks:i}=e,s=i.beforeTitle.apply(this,[t]),n=i.title.apply(this,[t]),o=i.afterTitle.apply(this,[t]);let a=[];return a=Do(a,Co(s)),a=Do(a,Co(n)),a=Do(a,Co(o)),a}getBeforeBody(t,e){return Io(e.callbacks.beforeBody.apply(this,[t]))}getBody(t,e){const{callbacks:i}=e,s=[];return b(t,(t=>{const e={before:[],lines:[],after:[]},n=zo(i,t);Do(e.before,Co(n.beforeLabel.call(this,t))),Do(e.lines,n.label.call(this,t)),Do(e.after,Co(n.afterLabel.call(this,t))),s.push(e)})),s}getAfterBody(t,e){return Io(e.callbacks.afterBody.apply(this,[t]))}getFooter(t,e){const{callbacks:i}=e,s=i.beforeFooter.apply(this,[t]),n=i.footer.apply(this,[t]),o=i.afterFooter.apply(this,[t]);let a=[];return a=Do(a,Co(s)),a=Do(a,Co(n)),a=Do(a,Co(o)),a}_createItems(t){const e=this._active,i=this.chart.data,s=[],n=[],o=[];let a,r,l=[];for(a=0,r=e.length;at.filter(e,s,n,i)))),t.itemSort&&(l=l.sort(((e,s)=>t.itemSort(e,s,i)))),b(l,(e=>{const i=zo(t.callbacks,e);s.push(i.labelColor.call(this,e)),n.push(i.labelPointStyle.call(this,e)),o.push(i.labelTextColor.call(this,e))})),this.labelColors=s,this.labelPointStyles=n,this.labelTextColors=o,this.dataPoints=l,l}update(t,e){const i=this.options.setContext(this.getContext()),s=this._active;let n,o=[];if(s.length){const t=Po[i.position].call(this,s,this._eventPosition);o=this._createItems(i),this.title=this.getTitle(o,i),this.beforeBody=this.getBeforeBody(o,i),this.body=this.getBody(o,i),this.afterBody=this.getAfterBody(o,i),this.footer=this.getFooter(o,i);const e=this._size=Ao(this,i),a=Object.assign({},t,e),r=Ro(this.chart,i,a),l=Lo(i,a,r,this.chart);this.xAlign=r.xAlign,this.yAlign=r.yAlign,n={opacity:1,x:l.x,y:l.y,width:e.width,height:e.height,caretX:t.x,caretY:t.y}}else 0!==this.opacity&&(n={opacity:0});this._tooltipItems=o,this.$context=void 0,n&&this._resolveAnimations().update(this,n),t&&i.external&&i.external.call(this,{chart:this.chart,tooltip:this,replay:e})}drawCaret(t,e,i,s){const n=this.getCaretPosition(t,i,s);e.lineTo(n.x1,n.y1),e.lineTo(n.x2,n.y2),e.lineTo(n.x3,n.y3)}getCaretPosition(t,e,i){const{xAlign:s,yAlign:n}=this,{caretSize:o,cornerRadius:a}=i,{topLeft:r,topRight:l,bottomLeft:h,bottomRight:c}=pe(a),{x:d,y:u}=t,{width:f,height:g}=e;let p,m,x,b,y,_;return"center"===n?(y=u+g/2,"left"===s?(p=d,m=p-o,b=y+o,_=y-o):(p=d+f,m=p+o,b=y-o,_=y+o),x=p):(m="left"===s?d+Math.max(r,h)+o:"right"===s?d+f-Math.max(l,c)-o:this.caretX,"top"===n?(b=u,y=b-o,p=m-o,x=m+o):(b=u+g,y=b+o,p=m+o,x=m-o),_=b),{x1:p,x2:m,x3:x,y1:b,y2:y,y3:_}}drawTitle(t,e,i){const s=this.title,n=s.length;let o,a,r;if(n){const l=ui(i.rtl,this.x,this.width);for(t.x=Eo(this,i.titleAlign,i),e.textAlign=l.textAlign(i.titleAlign),e.textBaseline="middle",o=xe(i.titleFont),a=i.titleSpacing,e.fillStyle=i.titleColor,e.font=o.string,r=0;r0!==t))?(t.beginPath(),t.fillStyle=n.multiKeyBackground,he(t,{x:e,y:g,w:l,h:r,radius:a}),t.fill(),t.stroke(),t.fillStyle=o.backgroundColor,t.beginPath(),he(t,{x:i,y:g+1,w:l-2,h:r-2,radius:a}),t.fill()):(t.fillStyle=n.multiKeyBackground,t.fillRect(e,g,l,r),t.strokeRect(e,g,l,r),t.fillStyle=o.backgroundColor,t.fillRect(i,g+1,l-2,r-2))}t.fillStyle=this.labelTextColors[i]}drawBody(t,e,i){const{body:s}=this,{bodySpacing:n,bodyAlign:o,displayColors:a,boxHeight:r,boxWidth:l,boxPadding:h}=i,c=xe(i.bodyFont);let d=c.lineHeight,u=0;const f=ui(i.rtl,this.x,this.width),g=function(i){e.fillText(i,f.x(t.x+u),t.y+d/2),t.y+=d+n},p=f.textAlign(o);let m,x,y,_,v,w,M;for(e.textAlign=o,e.textBaseline="middle",e.font=c.string,t.x=Eo(this,p,i),e.fillStyle=i.bodyColor,b(this.beforeBody,g),u=a&&"right"!==p?"center"===o?l/2+h:l+2+h:0,_=0,w=s.length;_0&&e.stroke()}_updateAnimationTarget(t){const e=this.chart,i=this.$animations,s=i&&i.x,n=i&&i.y;if(s||n){const i=Po[t.position].call(this,this._active,this._eventPosition);if(!i)return;const o=this._size=Ao(this,t),a=Object.assign({},i,this._size),r=Ro(e,t,a),l=Lo(t,a,r,e);s._to===l.x&&n._to===l.y||(this.xAlign=r.xAlign,this.yAlign=r.yAlign,this.width=o.width,this.height=o.height,this.caretX=i.x,this.caretY=i.y,this._resolveAnimations().update(this,l))}}_willRender(){return!!this.opacity}draw(t){const e=this.options.setContext(this.getContext());let i=this.opacity;if(!i)return;this._updateAnimationTarget(e);const s={width:this.width,height:this.height},n={x:this.x,y:this.y};i=Math.abs(i)<.001?0:i;const o=me(e.padding),a=this.title.length||this.beforeBody.length||this.body.length||this.afterBody.length||this.footer.length;e.enabled&&a&&(t.save(),t.globalAlpha=i,this.drawBackground(n,t,s,e),fi(t,e.textDirection),n.y+=o.top,this.drawTitle(n,t,e),this.drawBody(n,t,e),this.drawFooter(n,t,e),gi(t,e.textDirection),t.restore())}getActiveElements(){return this._active||[]}setActiveElements(t,e){const i=this._active,s=t.map((({datasetIndex:t,index:e})=>{const i=this.chart.getDatasetMeta(t);if(!i)throw new Error("Cannot find a dataset at index "+t);return{datasetIndex:t,element:i.data[e],index:e}})),n=!y(i,s),o=this._positionChanged(s,e);(n||o)&&(this._active=s,this._eventPosition=e,this._ignoreReplayEvents=!0,this.update(!0))}handleEvent(t,e,i=!0){if(e&&this._ignoreReplayEvents)return!1;this._ignoreReplayEvents=!1;const s=this.options,n=this._active||[],o=this._getActiveElements(t,n,e,i),a=this._positionChanged(o,t),r=e||!y(o,n)||a;return r&&(this._active=o,(s.enabled||s.external)&&(this._eventPosition={x:t.x,y:t.y},this.update(!0,e))),r}_getActiveElements(t,e,i,s){const n=this.options;if("mouseout"===t.type)return[];if(!s)return e;const o=this.chart.getElementsAtEventForMode(t,n.mode,n,i);return n.reverse&&o.reverse(),o}_positionChanged(t,e){const{caretX:i,caretY:s,options:n}=this,o=Po[n.position].call(this,t,e);return!1!==o&&(i!==o.x||s!==o.y)}}Fo.positioners=Po;var Wo={id:"tooltip",_element:Fo,positioners:Po,afterInit(t,e,i){i&&(t.tooltip=new Fo({chart:t,options:i}))},beforeUpdate(t,e,i){t.tooltip&&t.tooltip.initialize(i)},reset(t,e,i){t.tooltip&&t.tooltip.initialize(i)},afterDraw(t){const e=t.tooltip;if(e&&e._willRender()){const i={tooltip:e};if(!1===t.notifyPlugins("beforeTooltipDraw",i))return;e.draw(t.ctx),t.notifyPlugins("afterTooltipDraw",i)}},afterEvent(t,e){if(t.tooltip){const i=e.replay;t.tooltip.handleEvent(e.event,i,e.inChartArea)&&(e.changed=!0)}},defaults:{enabled:!0,external:null,position:"average",backgroundColor:"rgba(0,0,0,0.8)",titleColor:"#fff",titleFont:{weight:"bold"},titleSpacing:2,titleMarginBottom:6,titleAlign:"left",bodyColor:"#fff",bodySpacing:2,bodyFont:{},bodyAlign:"left",footerColor:"#fff",footerSpacing:2,footerMarginTop:6,footerFont:{weight:"bold"},footerAlign:"left",padding:6,caretPadding:2,caretSize:5,cornerRadius:6,boxHeight:(t,e)=>e.bodyFont.size,boxWidth:(t,e)=>e.bodyFont.size,multiKeyBackground:"#fff",displayColors:!0,boxPadding:0,borderColor:"rgba(0,0,0,0)",borderWidth:0,animation:{duration:400,easing:"easeOutQuart"},animations:{numbers:{type:"number",properties:["x","y","width","height","caretX","caretY"]},opacity:{easing:"linear",duration:200}},callbacks:{beforeTitle:l,title(t){if(t.length>0){const e=t[0],i=e.chart.data.labels,s=i?i.length:0;if(this&&this.options&&"dataset"===this.options.mode)return e.dataset.label||"";if(e.label)return e.label;if(s>0&&e.dataIndex"filter"!==t&&"itemSort"!==t&&"external"!==t,_indexable:!1,callbacks:{_scriptable:!1,_indexable:!1},animation:{_fallback:!1},animations:{_fallback:"animation"}},additionalOptionScopes:["interaction"]},Vo=Object.freeze({__proto__:null,Decimation:eo,Filler:bo,Legend:vo,SubTitle:So,Title:Mo,Tooltip:Wo});function jo(t,e,i,s){const n=t.indexOf(e);if(-1===n)return((t,e,i,s)=>("string"==typeof e?(i=t.push(e)-1,s.unshift({index:i,label:e})):isNaN(e)&&(i=null),i))(t,e,i,s);return n!==t.lastIndexOf(e)?i:n}class Bo extends Qs{constructor(t){super(t),this._startValue=void 0,this._valueRange=0,this._addedLabels=[]}init(t){const e=this._addedLabels;if(e.length){const t=this.getLabels();for(const{index:i,label:s}of e)t[i]===s&&t.splice(i,1);this._addedLabels=[]}super.init(t)}parse(t,e){if(c(t))return null;const i=this.getLabels();return e=isFinite(e)&&i[e]===t?e:jo(i,t,p(e,t),this._addedLabels),s=e,n=i.length-1,null===s?null:st(Math.round(s),0,n);var s,n}determineDataLimits(){const{minDefined:t,maxDefined:e}=this.getUserBounds();let{min:i,max:s}=this.getMinMax(!0);"ticks"===this.options.bounds&&(t||(i=0),e||(s=this.getLabels().length-1)),this.min=i,this.max=s}buildTicks(){const t=this.min,e=this.max,i=this.options.offset,s=[];let n=this.getLabels();n=0===t&&e===n.length-1?n:n.slice(t,e+1),this._valueRange=Math.max(n.length-(i?0:1),1),this._startValue=this.min-(i?.5:0);for(let i=t;i<=e;i++)s.push({value:i});return s}getLabelForValue(t){const e=this.getLabels();return t>=0&&te.length-1?null:this.getPixelForValue(e[t].value)}getValueForPixel(t){return Math.round(this._startValue+this.getDecimalForPixel(t)*this._valueRange)}getBasePixel(){return this.bottom}}function No(t,e){const i=[],{bounds:s,step:n,min:o,max:a,precision:r,count:l,maxTicks:h,maxDigits:d,includeBounds:u}=t,f=n||1,g=h-1,{min:p,max:m}=e,x=!c(o),b=!c(a),y=!c(l),_=(m-p)/(d+1);let v,w,M,k,S=H((m-p)/g/f)*f;if(S<1e-14&&!x&&!b)return[{value:p},{value:m}];k=Math.ceil(m/S)-Math.floor(p/S),k>g&&(S=H(k*S/g/f)*f),c(r)||(v=Math.pow(10,r),S=Math.ceil(S*v)/v),"ticks"===s?(w=Math.floor(p/S)*S,M=Math.ceil(m/S)*S):(w=p,M=m),x&&b&&n&&U((a-o)/n,S/1e3)?(k=Math.round(Math.min((a-o)/S,h)),S=(a-o)/k,w=o,M=a):y?(w=x?o:w,M=b?a:M,k=l-1,S=(M-w)/k):(k=(M-w)/S,k=X(k,Math.round(k),S/1e3)?Math.round(k):Math.ceil(k));const P=Math.max(G(S),G(w));v=Math.pow(10,c(r)?P:r),w=Math.round(w*v)/v,M=Math.round(M*v)/v;let D=0;for(x&&(u&&w!==o?(i.push({value:o}),ws=e?s:t,a=t=>n=i?n:t;if(t){const t=N(s),e=N(n);t<0&&e<0?a(0):t>0&&e>0&&o(0)}if(s===n){let e=1;(n>=Number.MAX_SAFE_INTEGER||s<=Number.MIN_SAFE_INTEGER)&&(e=Math.abs(.05*n)),a(n+e),t||o(s-e)}this.min=s,this.max=n}getTickLimit(){const t=this.options.ticks;let e,{maxTicksLimit:i,stepSize:s}=t;return s?(e=Math.ceil(this.max/s)-Math.floor(this.min/s)+1,e>1e3&&(console.warn(`scales.${this.id}.ticks.stepSize: ${s} would result generating up to ${e} ticks. Limiting to 1000.`),e=1e3)):(e=this.computeTickLimit(),i=i||11),i&&(e=Math.min(i,e)),e}computeTickLimit(){return Number.POSITIVE_INFINITY}buildTicks(){const t=this.options,e=t.ticks;let i=this.getTickLimit();i=Math.max(2,i);const s=No({maxTicks:i,bounds:t.bounds,min:t.min,max:t.max,precision:e.precision,step:e.stepSize,count:e.count,maxDigits:this._maxDigits(),horizontal:this.isHorizontal(),minRotation:e.minRotation||0,includeBounds:!1!==e.includeBounds},this._range||this);return"ticks"===t.bounds&&q(s,this,"value"),t.reverse?(s.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),s}configure(){const t=this.ticks;let e=this.min,i=this.max;if(super.configure(),this.options.offset&&t.length){const s=(i-e)/Math.max(t.length-1,1)/2;e-=s,i+=s}this._startValue=e,this._endValue=i,this._valueRange=i-e}getLabelForValue(t){return di(t,this.chart.options.locale,this.options.ticks.format)}}class Yo extends $o{determineDataLimits(){const{min:t,max:e}=this.getMinMax(!0);this.min=f(t)?t:0,this.max=f(e)?e:1,this.handleTickRangeOptions()}computeTickLimit(){const t=this.isHorizontal(),e=t?this.width:this.height,i=K(this.options.ticks.minRotation),s=(t?Math.sin(i):Math.cos(i))||.001,n=this._resolveTickFontOptions(0);return Math.ceil(e/Math.min(40,n.lineHeight/s))}getPixelForValue(t){return null===t?NaN:this.getPixelForDecimal((t-this._startValue)/this._valueRange)}getValueForPixel(t){return this._startValue+this.getDecimalForPixel(t)*this._valueRange}}function Xo(t){return 1===t/Math.pow(10,Math.floor(B(t)))}Yo.id="linear",Yo.defaults={ticks:{callback:$s.formatters.numeric}};class Uo extends Qs{constructor(t){super(t),this.start=void 0,this.end=void 0,this._startValue=void 0,this._valueRange=0}parse(t,e){const i=$o.prototype.parse.apply(this,[t,e]);if(0!==i)return f(i)&&i>0?i:null;this._zero=!0}determineDataLimits(){const{min:t,max:e}=this.getMinMax(!0);this.min=f(t)?Math.max(0,t):null,this.max=f(e)?Math.max(0,e):null,this.options.beginAtZero&&(this._zero=!0),this.handleTickRangeOptions()}handleTickRangeOptions(){const{minDefined:t,maxDefined:e}=this.getUserBounds();let i=this.min,s=this.max;const n=e=>i=t?i:e,o=t=>s=e?s:t,a=(t,e)=>Math.pow(10,Math.floor(B(t))+e);i===s&&(i<=0?(n(1),o(10)):(n(a(i,-1)),o(a(s,1)))),i<=0&&n(a(s,-1)),s<=0&&o(a(i,1)),this._zero&&this.min!==this._suggestedMin&&i===a(this.min,0)&&n(a(i,-1)),this.min=i,this.max=s}buildTicks(){const t=this.options,e=function(t,e){const i=Math.floor(B(e.max)),s=Math.ceil(e.max/Math.pow(10,i)),n=[];let o=g(t.min,Math.pow(10,Math.floor(B(e.min)))),a=Math.floor(B(o)),r=Math.floor(o/Math.pow(10,a)),l=a<0?Math.pow(10,Math.abs(a)):1;do{n.push({value:o,major:Xo(o)}),++r,10===r&&(r=1,++a,l=a>=0?1:l),o=Math.round(r*Math.pow(10,a)*l)/l}while(an?{start:e-i,end:e}:{start:e,end:e+i}}function Jo(t){const e={l:t.left+t._padding.left,r:t.right-t._padding.right,t:t.top+t._padding.top,b:t.bottom-t._padding.bottom},i=Object.assign({},e),s=[],n=[],o=t._pointLabels.length,a=t.options.pointLabels,r=a.centerPointLabels?L/o:0;for(let u=0;ue.r&&(r=(s.end-e.r)/o,t.r=Math.max(t.r,e.r+r)),n.starte.b&&(l=(n.end-e.b)/a,t.b=Math.max(t.b,e.b+l))}function Zo(t){return 0===t||180===t?"center":t<180?"left":"right"}function Qo(t,e,i){return"right"===i?t-=e:"center"===i&&(t-=e/2),t}function ta(t,e,i){return 90===i||270===i?t-=e/2:(i>270||i<90)&&(t-=e),t}function ea(t,e,i,s){const{ctx:n}=t;if(i)n.arc(t.xCenter,t.yCenter,e,0,E);else{let i=t.getPointPosition(0,e);n.moveTo(i.x,i.y);for(let o=1;o{const i=x(this.options.pointLabels.callback,[t,e],this);return i||0===i?i:""})).filter(((t,e)=>this.chart.getDataVisibility(e)))}fit(){const t=this.options;t.display&&t.pointLabels.display?Jo(this):this.setCenterPoint(0,0,0,0)}setCenterPoint(t,e,i,s){this.xCenter+=Math.floor((t-e)/2),this.yCenter+=Math.floor((i-s)/2),this.drawingArea-=Math.min(this.drawingArea/2,Math.max(t,e,i,s))}getIndexAngle(t){return et(t*(E/(this._pointLabels.length||1))+K(this.options.startAngle||0))}getDistanceFromCenterForValue(t){if(c(t))return NaN;const e=this.drawingArea/(this.max-this.min);return this.options.reverse?(this.max-t)*e:(t-this.min)*e}getValueForDistanceFromCenter(t){if(c(t))return NaN;const e=t/(this.drawingArea/(this.max-this.min));return this.options.reverse?this.max-e:this.min+e}getPointLabelContext(t){const e=this._pointLabels||[];if(t>=0&&t=0;n--){const e=s.setContext(t.getPointLabelContext(n)),o=xe(e.font),{x:a,y:r,textAlign:l,left:h,top:d,right:u,bottom:f}=t._pointLabelItems[n],{backdropColor:g}=e;if(!c(g)){const t=pe(e.borderRadius),s=me(e.backdropPadding);i.fillStyle=g;const n=h-s.left,o=d-s.top,a=u-h+s.width,r=f-d+s.height;Object.values(t).some((t=>0!==t))?(i.beginPath(),he(i,{x:n,y:o,w:a,h:r,radius:t}),i.fill()):i.fillRect(n,o,a,r)}re(i,t._pointLabels[n],a,r+o.lineHeight/2,o,{color:e.color,textAlign:l,textBaseline:"middle"})}}(this,n),s.display&&this.ticks.forEach(((t,e)=>{if(0!==e){a=this.getDistanceFromCenterForValue(t.value);!function(t,e,i,s){const n=t.ctx,o=e.circular,{color:a,lineWidth:r}=e;!o&&!s||!a||!r||i<0||(n.save(),n.strokeStyle=a,n.lineWidth=r,n.setLineDash(e.borderDash),n.lineDashOffset=e.borderDashOffset,n.beginPath(),ea(t,i,o,s),n.closePath(),n.stroke(),n.restore())}(this,s.setContext(this.getContext(e-1)),a,n)}})),i.display){for(t.save(),o=n-1;o>=0;o--){const s=i.setContext(this.getPointLabelContext(o)),{color:n,lineWidth:l}=s;l&&n&&(t.lineWidth=l,t.strokeStyle=n,t.setLineDash(s.borderDash),t.lineDashOffset=s.borderDashOffset,a=this.getDistanceFromCenterForValue(e.ticks.reverse?this.min:this.max),r=this.getPointPosition(o,a),t.beginPath(),t.moveTo(this.xCenter,this.yCenter),t.lineTo(r.x,r.y),t.stroke())}t.restore()}}drawBorder(){}drawLabels(){const t=this.ctx,e=this.options,i=e.ticks;if(!i.display)return;const s=this.getIndexAngle(0);let n,o;t.save(),t.translate(this.xCenter,this.yCenter),t.rotate(s),t.textAlign="center",t.textBaseline="middle",this.ticks.forEach(((s,a)=>{if(0===a&&!e.reverse)return;const r=i.setContext(this.getContext(a)),l=xe(r.font);if(n=this.getDistanceFromCenterForValue(this.ticks[a].value),r.showLabelBackdrop){t.font=l.string,o=t.measureText(s.label).width,t.fillStyle=r.backdropColor;const e=me(r.backdropPadding);t.fillRect(-o/2-e.left,-n-l.size/2-e.top,o+e.width,l.size+e.height)}re(t,s.label,0,-n,l,{color:r.color})})),t.restore()}drawTitle(){}}ia.id="radialLinear",ia.defaults={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:$s.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback:t=>t,padding:5,centerPointLabels:!1}},ia.defaultRoutes={"angleLines.color":"borderColor","pointLabels.color":"color","ticks.color":"color"},ia.descriptors={angleLines:{_fallback:"grid"}};const sa={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},na=Object.keys(sa);function oa(t,e){return t-e}function aa(t,e){if(c(e))return null;const i=t._adapter,{parser:s,round:n,isoWeekday:o}=t._parseOpts;let a=e;return"function"==typeof s&&(a=s(a)),f(a)||(a="string"==typeof s?i.parse(a,s):i.parse(a)),null===a?null:(n&&(a="week"!==n||!Y(o)&&!0!==o?i.startOf(a,n):i.startOf(a,"isoWeek",o)),+a)}function ra(t,e,i,s){const n=na.length;for(let o=na.indexOf(t);o=e?i[s]:i[n]]=!0}}else t[e]=!0}function ha(t,e,i){const s=[],n={},o=e.length;let a,r;for(a=0;a=0&&(e[l].major=!0);return e}(t,s,n,i):s}class ca extends Qs{constructor(t){super(t),this._cache={data:[],labels:[],all:[]},this._unit="day",this._majorUnit=void 0,this._offsets={},this._normalized=!1,this._parseOpts=void 0}init(t,e){const i=t.time||(t.time={}),s=this._adapter=new os._date(t.adapters.date);k(i.displayFormats,s.formats()),this._parseOpts={parser:i.parser,round:i.round,isoWeekday:i.isoWeekday},super.init(t),this._normalized=e.normalized}parse(t,e){return void 0===t?null:aa(this,t)}beforeLayout(){super.beforeLayout(),this._cache={data:[],labels:[],all:[]}}determineDataLimits(){const t=this.options,e=this._adapter,i=t.time.unit||"day";let{min:s,max:n,minDefined:o,maxDefined:a}=this.getUserBounds();function r(t){o||isNaN(t.min)||(s=Math.min(s,t.min)),a||isNaN(t.max)||(n=Math.max(n,t.max))}o&&a||(r(this._getLabelBounds()),"ticks"===t.bounds&&"labels"===t.ticks.source||r(this.getMinMax(!1))),s=f(s)&&!isNaN(s)?s:+e.startOf(Date.now(),i),n=f(n)&&!isNaN(n)?n:+e.endOf(Date.now(),i)+1,this.min=Math.min(s,n-1),this.max=Math.max(s+1,n)}_getLabelBounds(){const t=this.getLabelTimestamps();let e=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY;return t.length&&(e=t[0],i=t[t.length-1]),{min:e,max:i}}buildTicks(){const t=this.options,e=t.time,i=t.ticks,s="labels"===i.source?this.getLabelTimestamps():this._generate();"ticks"===t.bounds&&s.length&&(this.min=this._userMin||s[0],this.max=this._userMax||s[s.length-1]);const n=this.min,o=ke(s,n,this.max);return this._unit=e.unit||(i.autoSkip?ra(e.minUnit,this.min,this.max,this._getLabelCapacity(n)):function(t,e,i,s,n){for(let o=na.length-1;o>=na.indexOf(i);o--){const i=na[o];if(sa[i].common&&t._adapter.diff(n,s,i)>=e-1)return i}return na[i?na.indexOf(i):0]}(this,o.length,e.minUnit,this.min,this.max)),this._majorUnit=i.major.enabled&&"year"!==this._unit?function(t){for(let e=na.indexOf(t)+1,i=na.length;e+t.value)))}initOffsets(t){let e,i,s=0,n=0;this.options.offset&&t.length&&(e=this.getDecimalForValue(t[0]),s=1===t.length?1-e:(this.getDecimalForValue(t[1])-e)/2,i=this.getDecimalForValue(t[t.length-1]),n=1===t.length?i:(i-this.getDecimalForValue(t[t.length-2]))/2);const o=t.length<3?.5:.25;s=st(s,0,o),n=st(n,0,o),this._offsets={start:s,end:n,factor:1/(s+1+n)}}_generate(){const t=this._adapter,e=this.min,i=this.max,s=this.options,n=s.time,o=n.unit||ra(n.minUnit,e,i,this._getLabelCapacity(e)),a=p(n.stepSize,1),r="week"===o&&n.isoWeekday,l=Y(r)||!0===r,h={};let c,d,u=e;if(l&&(u=+t.startOf(u,"isoWeek",r)),u=+t.startOf(u,l?"day":o),t.diff(i,e,o)>1e5*a)throw new Error(e+" and "+i+" are too far apart with stepSize of "+a+" "+o);const f="data"===s.ticks.source&&this.getDataTimestamps();for(c=u,d=0;ct-e)).map((t=>+t))}getLabelForValue(t){const e=this._adapter,i=this.options.time;return i.tooltipFormat?e.format(t,i.tooltipFormat):e.format(t,i.displayFormats.datetime)}_tickFormatFunction(t,e,i,s){const n=this.options,o=n.time.displayFormats,a=this._unit,r=this._majorUnit,l=a&&o[a],h=r&&o[r],c=i[e],d=r&&h&&c&&c.major,u=this._adapter.format(t,s||(d?h:l)),f=n.ticks.callback;return f?x(f,[u,e,i],this):u}generateTickLabels(t){let e,i,s;for(e=0,i=t.length;e0?a:1}getDataTimestamps(){let t,e,i=this._cache.data||[];if(i.length)return i;const s=this.getMatchingVisibleMetas();if(this._normalized&&s.length)return this._cache.data=s[0].controller.getAllParsedValues(this);for(t=0,e=s.length;t=t[r].pos&&e<=t[l].pos&&({lo:r,hi:l}=we(t,"pos",e)),({pos:s,time:o}=t[r]),({pos:n,time:a}=t[l])):(e>=t[r].time&&e<=t[l].time&&({lo:r,hi:l}=we(t,"time",e)),({time:s,pos:o}=t[r]),({time:n,pos:a}=t[l]));const h=n-s;return h?o+(a-o)*(e-s)/h:o}ca.id="time",ca.defaults={bounds:"data",adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{}},ticks:{source:"auto",major:{enabled:!1}}};class ua extends ca{constructor(t){super(t),this._table=[],this._minPos=void 0,this._tableRange=void 0}initOffsets(){const t=this._getTimestampsForTable(),e=this._table=this.buildLookupTable(t);this._minPos=da(e,this.min),this._tableRange=da(e,this.max)-this._minPos,super.initOffsets(t)}buildLookupTable(t){const{min:e,max:i}=this,s=[],n=[];let o,a,r,l,h;for(o=0,a=t.length;o=e&&l<=i&&s.push(l);if(s.length<2)return[{time:e,pos:0},{time:i,pos:1}];for(o=0,a=s.length;o{delete n.clickTimeout,ba(a,n,e)}),i.dblClickSpeed):ba(a,n,e)}}(t,e,i)}}function ba(t,e,i){x(t,[e.$context,i])}function ya(t,e){let i=Number.POSITIVE_INFINITY;return t.filter((t=>t.options.display&&t.inRange(e.x,e.y))).reduce(((t,s)=>{const n=s.getCenterPoint(),o=Q(e,n);return ot._index-e._index)).slice(0,1)[0]}function _a(t,e,i){const s=function(t,e){const i=t.axis,s=t.id,n=i+"ScaleID",o={min:p(t.min,Number.NEGATIVE_INFINITY),max:p(t.max,Number.POSITIVE_INFINITY)};for(const a of e)a.scaleID===s?ka(a,t,["value","endValue"],o):a[n]===s&&ka(a,t,[i+"Min",i+"Max",i+"Value"],o);return o}(e,i);let n=va(e,s,"min","suggestedMin");n=va(e,s,"max","suggestedMax")||n,n&&"function"==typeof e.handleTickRangeOptions&&e.handleTickRangeOptions()}function va(t,e,i,s){if(f(e[i])&&!function(t,e,i){return O(t[e])||O(t[i])}(t.options,i,s)){const s=t[i]!==e[i];return t[i]=e[i],s}}function wa(t,e){for(const i of["scaleID","xScaleID","yScaleID"])t[i]&&!e[t[i]]&&Ma(t,i)&&console.warn(`No scale found with id '${t[i]}' for annotation '${t.id}'`)}function Ma(t,e){if("scaleID"===e)return!0;const i=e.charAt(0);for(const e of["Min","Max","Value"])if(O(t[i+e]))return!0;return!1}function ka(t,e,i,s){for(const n of i){const i=t[n];if(O(i)){const t=e.parse(i);s.min=Math.min(s.min,t),s.max=Math.max(s.max,t)}}}const Sa=(t,e,i)=>Math.min(i,Math.max(e,t));function Pa(t,e,i){for(const s of Object.keys(t))t[s]=Sa(t[s],e,i);return t}function Da(t,e,{x:i,y:s,width:n,height:o},a){const r=a/2;return t>=i-r-.001&&t<=i+n+r+.001&&e>=s-r-.001&&e<=s+o+r+.001}function Ca(t,e){const{x:i,y:s}=t.getProps(["x","y"],e);return{x:i,y:s}}const Oa=(t,e)=>e>t||t.length>e.length&&t.substr(0,e.length)===e;const Aa=t=>"string"==typeof t&&t.endsWith("%"),Ta=t=>Sa(parseFloat(t)/100,0,1);function Ra(t,e){return"start"===e?0:"end"===e?t:Aa(e)?Ta(e)*t:t/2}function La(t,e){return"number"==typeof e?e:Aa(e)?Ta(e)*t:t}function Ea(t){return u(t)?{x:p(t.x,"center"),y:p(t.y,"center")}:{x:t=p(t,"center"),y:t}}function Ia(t){return t&&(O(t.xValue)||O(t.yValue))}const za=new Map;function Fa(t){if(t&&"object"==typeof t){const e=t.toString();return"[object HTMLImageElement]"===e||"[object HTMLCanvasElement]"===e}}function Wa(t,e,i){if(i){const s=e.getCenterPoint();t.translate(s.x,s.y),t.rotate(K(i)),t.translate(-s.x,-s.y)}}function Va(t,e){if(e&&e.borderWidth)return t.lineCap=e.borderCapStyle,t.setLineDash(e.borderDash),t.lineDashOffset=e.borderDashOffset,t.lineJoin=e.borderJoinStyle,t.lineWidth=e.borderWidth,t.strokeStyle=e.borderColor,!0}function ja(t,e){t.shadowColor=e.backgroundShadowColor,t.shadowBlur=e.shadowBlur,t.shadowOffsetX=e.shadowOffsetX,t.shadowOffsetY=e.shadowOffsetY}function Ba(t,e){const i=e.content;if(Fa(i))return{width:La(i.width,e.width),height:La(i.height,e.height)};const s=xe(e.font),n=e.textStrokeWidth,o=d(i)?i:[i],a=o.join()+s.string+n+(t._measureText?"-spriting":"");if(!za.has(a)){t.save(),t.font=s.string;const e=o.length;let i=0;for(let s=0;s0)return t.lineJoin="round",t.miterLimit=2,t.lineWidth=e.textStrokeWidth,t.strokeStyle=e.textStrokeColor,!0}(t,i)&&n.forEach(((e,i)=>t.strokeText(e,r,l+i*a))),t.fillStyle=i.color,n.forEach(((e,i)=>t.fillText(e,r,l+i*a))),t.restore()}function $a(t){const{x:e,y:i,width:s,height:n}=t;return{x:e+s/2,y:i+n/2}}function Ya(t,e,i){const s=Math.cos(i),n=Math.sin(i),o=e.x,a=e.y;return{x:o+s*(t.x-o)-n*(t.y-a),y:a+n*(t.x-o)+s*(t.y-a)}}function Xa(t,e,i){return e="number"==typeof e?e:t.parse(e),f(e)?t.getPixelForValue(e):i}function Ua(t,e){if(t){const i=Xa(t,e.min,e.start),s=Xa(t,e.max,e.end);return{start:Math.min(i,s),end:Math.max(i,s)}}return{start:e.start,end:e.end}}function qa(t,e){const{chartArea:i,scales:s}=t,n=s[e.xScaleID],o=s[e.yScaleID];let a=i.width/2,r=i.height/2;return n&&(a=Xa(n,e.xValue,a)),o&&(r=Xa(o,e.yValue,r)),{x:a,y:r}}function Ka(t,e){const i=t.scales[e.xScaleID],s=t.scales[e.yScaleID];let{top:n,left:o,bottom:a,right:r}=t.chartArea;if(!i&&!s)return{};const l=Ua(i,{min:e.xMin,max:e.xMax,start:o,end:r});o=l.start,r=l.end;const h=Ua(s,{min:e.yMin,max:e.yMax,start:n,end:a});return n=h.start,a=h.end,{x:o,y:n,x2:r,y2:a,width:r-o,height:a-n}}function Ja(t,e){if(!Ia(e)){const i=Ka(t,e),s=$a(i);let n=e.radius;return n&&!isNaN(n)||(n=Math.min(i.width,i.height)/2,e.radius=n),{x:s.x+e.xAdjust,y:s.y+e.yAdjust,width:2*n,height:2*n}}return function(t,e){const i=qa(t,e);return{x:i.x+e.xAdjust,y:i.y+e.yAdjust,width:2*e.radius,height:2*e.radius}}(t,e)}class Ga extends Ns{inRange(t,e,i){const{x:s,y:n}=Ya({x:t,y:e},this.getCenterPoint(i),K(-this.options.rotation));return Da(s,n,this.getProps(["x","y","width","height"],i),this.options.borderWidth)}getCenterPoint(t){return $a(this.getProps(["x","y","width","height"],t))}draw(t){t.save(),Wa(t,this,this.options.rotation),Na(t,this,this.options),t.restore()}drawLabel(t){const{x:e,y:i,width:s,height:n,options:o}=this,{label:a,borderWidth:r}=o,l=r/2,h=Ea(a.position),c=me(a.padding),d=Ba(t,a),u={x:Za(this,d,h,c),y:Qa(this,d,h,c),width:d.width,height:d.height};t.save(),Wa(t,this,a.rotation),t.beginPath(),t.rect(e+l+c.left,i+l+c.top,s-r-c.width,n-r-c.height),t.clip(),Ha(t,u,a),t.restore()}resolveElementProperties(t,e){return Ka(t,e)}}function Za(t,e,i,s){const{x:n,x2:o,width:a,options:r}=t,{xAdjust:l,borderWidth:h}=r.label;return tr({start:n,end:o,size:a},{position:i.x,padding:{start:s.left,end:s.right},adjust:l,borderWidth:h,size:e.width})}function Qa(t,e,i,s){const{y:n,y2:o,height:a,options:r}=t,{yAdjust:l,borderWidth:h}=r.label;return tr({start:n,end:o,size:a},{position:i.y,padding:{start:s.top,end:s.bottom},adjust:l,borderWidth:h,size:e.height})}function tr(t,e){const{start:i,end:s}=t,{position:n,padding:{start:o,end:a},adjust:r,borderWidth:l}=e;return i+l/2+r+o+Ra(s-l-i-o-a-e.size,n)}Ga.id="boxAnnotation",Ga.defaults={adjustScaleRange:!0,backgroundShadowColor:"transparent",borderCapStyle:"butt",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",borderRadius:0,borderShadowColor:"transparent",borderWidth:1,cornerRadius:void 0,display:!0,label:{borderWidth:void 0,color:"black",content:null,drawTime:void 0,enabled:!1,font:{family:void 0,lineHeight:void 0,size:void 0,style:void 0,weight:"bold"},height:void 0,padding:6,position:"center",rotation:void 0,textAlign:"start",textStrokeColor:void 0,textStrokeWidth:0,xAdjust:0,yAdjust:0,width:void 0},rotation:0,shadowBlur:0,shadowOffsetX:0,shadowOffsetY:0,xMax:void 0,xMin:void 0,xScaleID:"x",yMax:void 0,yMin:void 0,yScaleID:"y"},Ga.defaultRoutes={borderColor:"color",backgroundColor:"color"},Ga.descriptors={label:{_fallback:!0}};const er=(t,e,i)=>({x:t.x+i*(e.x-t.x),y:t.y+i*(e.y-t.y)}),ir=(t,e,i)=>er(e,i,Math.abs((t-e.y)/(i.y-e.y))).x,sr=(t,e,i)=>er(e,i,Math.abs((t-e.x)/(i.x-e.x))).y,nr=t=>t*t;function or({x:t,y:e,x2:i,y2:s},{top:n,right:o,bottom:a,left:r}){return!(to&&i>o||ea&&s>a)}function ar({x:t,y:e},i,{top:s,right:n,bottom:o,left:a}){return tn&&(e=sr(n,{x:t,y:e},i),t=n),eo&&(t=ir(o,{x:t,y:e},i),e=o),{x:t,y:e}}class rr extends Ns{intersects(t,e,i=.001,s){const{x:n,y:o,x2:a,y2:r}=this.getProps(["x","y","x2","y2"],s),l=a-n,h=r-o,c=nr(l)+nr(h),d=0===c?-1:((t-n)*l+(e-o)*h)/c;let u,f;return d<0?(u=n,f=o):d>1?(u=a,f=r):(u=n+d*l,f=o+d*h),nr(t-u)+nr(e-f)<=i}labelIsVisible(t,e){const i=this.options.label;return!(!i||!i.enabled)&&(!e||or(this.getProps(["x","y","x2","y2"],t),e))}isOnLabel(t,e,i){if(!this.labelIsVisible(i))return!1;const{labelX:s,labelY:n,labelWidth:o,labelHeight:a,labelRotation:r}=this.getProps(["labelX","labelY","labelWidth","labelHeight","labelRotation"],i),{x:l,y:h}=Ya({x:t,y:e},{x:s,y:n},-r),c=this.options.label.borderWidth/2||0,d=o/2+c,u=a/2+c;return l>=s-d-.001&&l<=s+d+.001&&h>=n-u-.001&&h<=n+u+.001}inRange(t,e,i){const s=nr(this.options.borderWidth/2);return this.intersects(t,e,s,i)||this.isOnLabel(t,e,i)}getCenterPoint(){return{x:(this.x2+this.x)/2,y:(this.y2+this.y)/2}}draw(t){const{x:e,y:i,x2:s,y2:n,options:o}=this;if(t.save(),!Va(t,o))return t.restore();ja(t,o);const a=Math.atan2(n-i,s-e),r=Math.sqrt(Math.pow(s-e,2)+Math.pow(n-i,2)),{startOpts:l,endOpts:h,startAdjust:c,endAdjust:d}=function(t){const e=t.options,i=e.arrowHeads&&e.arrowHeads.start,s=e.arrowHeads&&e.arrowHeads.end;return{startOpts:i,endOpts:s,startAdjust:dr(t,i),endAdjust:dr(t,s)}}(this);t.translate(e,i),t.rotate(a),t.beginPath(),t.moveTo(0+c,0),t.lineTo(r-d,0),t.shadowColor=o.borderShadowColor,t.stroke(),ur(t,0,c,l),ur(t,r,-d,h),t.restore()}drawLabel(t,e){if(!this.labelIsVisible(!1,e))return;const{labelX:i,labelY:s,labelWidth:n,labelHeight:o,labelRotation:a,labelPadding:r,labelTextSize:l,options:{label:h}}=this;t.save(),t.translate(i,s),t.rotate(a);Na(t,{x:-n/2,y:-o/2,width:n,height:o},h);Ha(t,{x:-n/2+r.left+h.borderWidth/2,y:-o/2+r.top+h.borderWidth/2,width:l.width,height:l.height},h),t.restore()}resolveElementProperties(t,e){const i=t.scales[e.scaleID];let s,n,{top:o,left:a,bottom:r,right:l}=t.chartArea;if(i)s=Xa(i,e.value,NaN),n=Xa(i,e.endValue,s),i.isHorizontal()?(a=s,l=n):(o=s,r=n);else{const i=t.scales[e.xScaleID],s=t.scales[e.yScaleID];i&&(a=Xa(i,e.xMin,a),l=Xa(i,e.xMax,l)),s&&(o=Xa(s,e.yMin,o),r=Xa(s,e.yMax,r))}const h=or({x:a,y:o,x2:l,y2:r},t.chartArea)?function(t,e,i){const{x:s,y:n}=ar(t,e,i),{x:o,y:a}=ar(e,t,i);return{x:s,y:n,x2:o,y2:a,width:Math.abs(o-s),height:Math.abs(a-n)}}({x:a,y:o},{x:l,y:r},t.chartArea):{x:a,y:o,x2:l,y2:r,width:Math.abs(l-a),height:Math.abs(r-o)},c=e.label;return c&&c.content?function(t,e,i){const{padding:s,xPadding:n,yPadding:o,borderWidth:a}=i,r=function(t,e,i){let s=t;(e||i)&&(s={x:e||6,y:i||6});return me(s)}(s,n,o),l=Ba(e.ctx,i),h=l.width+r.width+a,c=l.height+r.height+a,d=function(t,e,i,s){const{width:n,height:o,padding:a}=i,{xAdjust:r,yAdjust:l}=e,h={x:t.x,y:t.y},c={x:t.x2,y:t.y2},d="auto"===e.rotation?function(t){const{x:e,y:i,x2:s,y2:n}=t,o=Math.atan2(n-i,s-e);return o>L/2?o-L:o0&&(n.w/2+o.left-s.x)/a,h=r>0&&(n.h/2+o.top-s.y)/r;return Sa(Math.max(l,h),0,.25)}function cr(t,e){const{size:i,min:s,max:n,padding:o}=e,a=i/2;return i>n-s?(n+s)/2:(s>=t-o-a&&(t=s+o+a),n<=t+o+a&&(t=n-o-a),t)}function dr(t,e){if(!e||!e.enabled)return 0;const{length:i,width:s}=e,n=t.options.borderWidth/2,o={x:i,y:s+n},a={x:0,y:n};return Math.abs(ir(0,o,a))}function ur(t,e,i,s){if(!s||!s.enabled)return;const{length:n,width:o,fill:a,backgroundColor:r,borderColor:l}=s,h=Math.abs(e-n)+i;t.beginPath(),ja(t,s),Va(t,s),t.moveTo(h,-o),t.lineTo(e+i,0),t.lineTo(h,o),!0===a?(t.fillStyle=r||l,t.closePath(),t.fill(),t.shadowColor="transparent"):t.shadowColor=s.borderShadowColor,t.stroke()}rr.defaults={adjustScaleRange:!0,arrowHeads:{enabled:!1,end:Object.assign({},lr),fill:!1,length:12,start:Object.assign({},lr),width:6},borderDash:[],borderDashOffset:0,borderShadowColor:"transparent",borderWidth:2,display:!0,endValue:void 0,label:{backgroundColor:"rgba(0,0,0,0.8)",backgroundShadowColor:"transparent",borderCapStyle:"butt",borderColor:"black",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",borderRadius:6,borderShadowColor:"transparent",borderWidth:0,color:"#fff",content:null,cornerRadius:void 0,drawTime:void 0,enabled:!1,font:{family:void 0,lineHeight:void 0,size:void 0,style:void 0,weight:"bold"},height:void 0,padding:6,position:"center",rotation:0,shadowBlur:0,shadowOffsetX:0,shadowOffsetY:0,textAlign:"center",textStrokeColor:void 0,textStrokeWidth:0,width:void 0,xAdjust:0,xPadding:void 0,yAdjust:0,yPadding:void 0},scaleID:void 0,shadowBlur:0,shadowOffsetX:0,shadowOffsetY:0,value:void 0,xMax:void 0,xMin:void 0,xScaleID:"x",yMax:void 0,yMin:void 0,yScaleID:"y"},rr.descriptors={arrowHeads:{start:{_fallback:!0},end:{_fallback:!0},_fallback:!0}},rr.defaultRoutes={borderColor:"color"};class fr extends Ns{inRange(t,e,i){return function(t,e,i,s){const{width:n,height:o}=e,a=e.getCenterPoint(!0),r=n/2,l=o/2;if(r<=0||l<=0)return!1;const h=K(i||0),c=s/2||0,d=Math.cos(h),u=Math.sin(h),f=Math.pow(d*(t.x-a.x)+u*(t.y-a.y),2),g=Math.pow(u*(t.x-a.x)-d*(t.y-a.y),2);return f/Math.pow(r+c,2)+g/Math.pow(l+c,2)<=1.0001}({x:t,y:e},this.getProps(["width","height"],i),this.options.rotation,this.options.borderWidth)}getCenterPoint(t){return $a(this.getProps(["x","y","width","height"],t))}draw(t){const{width:e,height:i,options:s}=this,n=this.getCenterPoint();t.save(),Wa(t,this,s.rotation),ja(t,this.options),t.beginPath(),t.fillStyle=s.backgroundColor;const o=Va(t,s);t.ellipse(n.x,n.y,i/2,e/2,L/2,0,2*L),t.fill(),o&&(t.shadowColor=s.borderShadowColor,t.stroke()),t.restore()}resolveElementProperties(t,e){return Ka(t,e)}}fr.id="ellipseAnnotation",fr.defaults={adjustScaleRange:!0,backgroundShadowColor:"transparent",borderDash:[],borderDashOffset:0,borderShadowColor:"transparent",borderWidth:1,display:!0,rotation:0,shadowBlur:0,shadowOffsetX:0,shadowOffsetY:0,xMax:void 0,xMin:void 0,xScaleID:"x",yMax:void 0,yMin:void 0,yScaleID:"y"},fr.defaultRoutes={borderColor:"color",backgroundColor:"color"};class gr extends Ns{inRange(t,e,i){const{x:s,y:n}=Ya({x:t,y:e},this.getCenterPoint(i),K(-this.options.rotation));return Da(s,n,this.getProps(["x","y","width","height"],i),this.options.borderWidth)}getCenterPoint(t){return $a(this.getProps(["x","y","width","height"],t))}draw(t){if(!this.options.content)return;const{labelX:e,labelY:i,labelWidth:s,labelHeight:n,options:o}=this;t.save(),Wa(t,this,o.rotation),function(t,e){const{pointX:i,pointY:s,calloutPosition:n,options:o}=e;if(!n||e.inRange(i,s))return;const a=o.callout;t.save(),t.beginPath();if(!Va(t,a))return t.restore();const{separatorStart:r,separatorEnd:l}=function(t,e){const{x:i,y:s,width:n,height:o}=t,a=function(t,e){const{width:i,height:s,options:n}=t,o=n.callout.margin+n.borderWidth/2;if("right"===e)return i+o;if("bottom"===e)return s+o;return-o}(t,e);let r,l;"left"===e||"right"===e?(r={x:i+a,y:s},l={x:r.x,y:r.y+o}):(r={x:i,y:s+a},l={x:r.x+n,y:r.y});return{separatorStart:r,separatorEnd:l}}(e,n),{sideStart:h,sideEnd:c}=function(t,e,i){const{y:s,width:n,height:o,options:a}=t,r=a.callout.start,l=function(t,e){const i=e.side;return"left"===t||"top"===t?-i:i}(e,a.callout);let h,c;"left"===e||"right"===e?(h={x:i.x,y:s+La(o,r)},c={x:h.x+l,y:h.y}):(h={x:i.x+La(n,r),y:i.y},c={x:h.x,y:h.y+l});return{sideStart:h,sideEnd:c}}(e,n,r);(a.margin>0||0===o.borderWidth)&&(t.moveTo(r.x,r.y),t.lineTo(l.x,l.y));t.moveTo(h.x,h.y),t.lineTo(c.x,c.y);const d=Ya({x:i,y:s},e.getCenterPoint(),K(-o.rotation));t.lineTo(d.x,d.y),t.stroke(),t.restore()}(t,this),Na(t,this,o),Ha(t,{x:e,y:i,width:s,height:n},o),t.restore()}resolveElementProperties(t,e){const i=Ia(e)?qa(t,e):$a(Ka(t,e)),s=me(e.padding),n=Ba(t.ctx,e),o=function(t,e,i,s){const n=e.width+s.width+i.borderWidth,o=e.height+s.height+i.borderWidth,a=Ea(i.position);return{x:pr(t.x,n,i.xAdjust,a.x),y:pr(t.y,o,i.yAdjust,a.y),width:n,height:o}}(i,n,e,s),a=e.borderWidth/2,r={pointX:i.x,pointY:i.y,...o,labelX:o.x+s.left+a,labelY:o.y+s.top+a,labelWidth:n.width,labelHeight:n.height};return r.calloutPosition=e.callout.enabled&&function(t,e,i){const s=e.position;return"left"===s||"right"===s||"top"===s||"bottom"===s?s:function(t,e,i){const{x:s,y:n,width:o,height:a,pointX:r,pointY:l}=t,h={x:s+o/2,y:n+a/2},c=e.start,d=La(o,c),u=La(a,c),f=[s,s+d,s+d,s+o],g=[n+u,n+a,n,n+u],p=[];for(let t=0;t<4;t++){const e=Ya({x:f[t],y:g[t]},h,K(i));p.push({position:mr[t],distance:Q(e,{x:r,y:l})})}return p.sort(((t,e)=>t.distance-e.distance))[0].position}(t,e,i)}(r,e.callout,e.rotation),r}}function pr(t,e,i=0,s){return t-Ra(e,s)+i}gr.id="labelAnnotation",gr.defaults={adjustScaleRange:!0,backgroundColor:"transparent",backgroundShadowColor:"transparent",borderCapStyle:"butt",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",borderRadius:0,borderShadowColor:"transparent",borderWidth:0,callout:{borderCapStyle:"butt",borderColor:void 0,borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",borderWidth:1,enabled:!1,margin:5,position:"auto",side:5,start:"50%"},color:"black",content:null,display:!0,font:{family:void 0,lineHeight:void 0,size:void 0,style:void 0,weight:void 0},height:void 0,padding:6,position:"center",rotation:0,shadowBlur:0,shadowOffsetX:0,shadowOffsetY:0,textAlign:"center",textStrokeColor:void 0,textStrokeWidth:0,width:void 0,xAdjust:0,xMax:void 0,xMin:void 0,xScaleID:"x",xValue:void 0,yAdjust:0,yMax:void 0,yMin:void 0,yScaleID:"y",yValue:void 0},gr.defaultRoutes={borderColor:"color"};const mr=["left","bottom","top","right"];class xr extends Ns{inRange(t,e,i){const{width:s}=this.getProps(["width"],i);return function(t,e,i,s){if(!t||!e||i<=0)return!1;const n=s/2||0;return Math.pow(t.x-e.x,2)+Math.pow(t.y-e.y,2)<=Math.pow(i+n,2)}({x:t,y:e},this.getCenterPoint(i),s/2,this.options.borderWidth)}getCenterPoint(t){return Ca(this,t)}draw(t){const e=this.options,i=e.borderWidth;if(e.radius<.1)return;t.save(),t.fillStyle=e.backgroundColor,ja(t,e);const s=Va(t,e);e.borderWidth=0,ee(t,e,this.x,this.y),s&&!Fa(e.pointStyle)&&(t.shadowColor=e.borderShadowColor,t.stroke()),t.restore(),e.borderWidth=i}resolveElementProperties(t,e){return Ja(t,e)}}xr.id="pointAnnotation",xr.defaults={adjustScaleRange:!0,backgroundShadowColor:"transparent",borderDash:[],borderDashOffset:0,borderShadowColor:"transparent",borderWidth:1,display:!0,pointStyle:"circle",radius:10,rotation:0,shadowBlur:0,shadowOffsetX:0,shadowOffsetY:0,xAdjust:0,xMax:void 0,xMin:void 0,xScaleID:"x",xValue:void 0,yAdjust:0,yMax:void 0,yMin:void 0,yScaleID:"y",yValue:void 0},xr.defaultRoutes={borderColor:"color",backgroundColor:"color"};class br extends Ns{inRange(t,e,i){return this.options.radius>=.1&&this.elements.length>1&&function(t,e,i,s){let n=!1,o=t[t.length-1].getProps(["bX","bY"],s);for(const a of t){const t=a.getProps(["bX","bY"],s);t.bY>i!=o.bY>i&&e<(o.bX-t.bX)*(i-t.bY)/(o.bY-t.bY)+t.bX&&(n=!n),o=t}return n}(this.elements,t,e,i)}getCenterPoint(t){return Ca(this,t)}draw(t){const{elements:e,options:i}=this;t.save(),t.beginPath(),t.fillStyle=i.backgroundColor,ja(t,i);const s=Va(t,i);let n=!0;for(const i of e)n?(t.moveTo(i.x,i.y),n=!1):t.lineTo(i.x,i.y);t.closePath(),t.fill(),s&&(t.shadowColor=i.borderShadowColor,t.stroke()),t.restore()}resolveElementProperties(t,e){const{x:i,y:s,width:n,height:o}=Ja(t,e),{sides:a,radius:r,rotation:l,borderWidth:h}=e,c=h/2,d=[],u=2*L/a;let f=l*F;for(let t=0;t{Jt.describe(`elements.${yr[t].id}`,{_fallback:"plugins.annotation"})}));const _r={update:Object.assign};function vr(t="line"){return yr[t]?t:(console.warn(`Unknown annotation type: '${t}', defaulting to 'line'`),"line")}function wr(t,e,i,s){const n=function(t,e,i){return"reset"===i||"none"===i||"resize"===i?_r:new Di(t,e)}(t,i.animations,s),o=e.annotations,a=function(t,e){const i=e.length,s=t.length;if(si&&t.splice(i,s-i);return t}(e.elements,o);for(let e=0;e{if(!("drawLabel"in t))return;const i=t.options.label;i&&i.enabled&&i.content&&(i.drawTime||t.options.drawTime)===e&&t.drawLabel(s,n)}))}function Tr(t,e,i){for(const s of e)s.options.drawTime===i&&s.draw(t)}function Rr(t,e){if(6===(t=t.replace("#","")).length){const i=parseInt(t,16);let s=(i>>16)+e;s>255&&(s=255),s<0&&(s=0);let n=(255&i)+e;n>255&&(n=255),n<0&&(n=0);let o=(i>>8&255)+e;return o>255&&(o=255),o<0&&(o=0),`#${(n|o<<8|s<<16).toString(16)}`}return t}fa.register({id:"annotation",version:"1.4.0",afterRegister(){Pn.register(yr),function(t,e,i,s=!0){const n=i.split(".");let o=0;for(const a of e.split(".")){const r=n[o++];if(parseInt(a,10){const e=n[t];u(e)&&(e.id=t,s.push(e))})):d(n)&&s.push(...n),function(t,e){for(const i of t)wa(i,e)}(s,t.scales)},afterDataLimits(t,e){const i=Or.get(t);_a(0,e.scale,i.annotations.filter((t=>t.display&&t.adjustScaleRange)))},afterUpdate(t,e,i){const s=Or.get(t);!function(t,e,i){e.listened=!1,e.moveListened=!1,ma.forEach((t=>{"function"==typeof i[t]?(e.listened=!0,e.listeners[t]=i[t]):O(e.listeners[t])&&delete e.listeners[t]})),pa.forEach((t=>{"function"==typeof i[t]&&(e.moveListened=!0)})),e.listened&&e.moveListened||e.annotations.forEach((t=>{e.listened||ga.forEach((i=>{"function"==typeof t[i]&&(e.listened=!0)})),e.moveListened||pa.forEach((i=>{"function"==typeof t[i]&&(e.listened=!0,e.moveListened=!0)}))}))}(0,s,i),wr(t,s,i,e.mode),s.visibleElements=s.elements.filter((t=>!t.skip&&t.options.display))},beforeDatasetsDraw(t,e,i){Ar(t,"beforeDatasetsDraw",i.clip)},afterDatasetsDraw(t,e,i){Ar(t,"afterDatasetsDraw",i.clip)},beforeDraw(t,e,i){Ar(t,"beforeDraw",i.clip)},afterDraw(t,e,i){Ar(t,"afterDraw",i.clip)},beforeEvent(t,e,i){xa(Or.get(t),e.event,i)},destroy(t){Or.delete(t)},_getState:t=>Or.get(t),defaults:{animations:{numbers:{properties:["x","y","x2","y2","width","height","pointX","pointY","labelX","labelY","labelWidth","labelHeight","radius"],type:"number"}},clip:!0,dblClickSpeed:350,drawTime:"afterDatasetsDraw",label:{drawTime:null}},descriptors:{_indexable:!1,_scriptable:t=>!ma.includes(t),annotations:{_allKeys:!1,_fallback:(t,e)=>`elements.${yr[vr(e.type)].id}`}},additionalOptionScopes:[""]});const Lr=["#8dd3c7","#ffffb3","#bebada","#fb8072","#80b1d3","#fdb462","#b3de69","#fccde5","#d9d9d9","#bc80bd","#ccebc5","#ffed6f"];function Er(t,e,i){return 2===e&&1===i?t+.04:t-.36}function Ir(t,e,i){return 2===e&&0===i?t-.04:t+.36}for(const i in t(e)){const s=document.getElementById(`${i}-chart`).getContext("2d"),n={animation:!1,elements:{bar:{borderWidth:1.5}},parsing:{xAxisKey:"id",yAxisKey:"avg"},responsive:!0,scales:{y:{beginAtZero:!0,min:0,title:{text:"seconds",display:!0}}},plugins:{legend:!1,tooltip:{callbacks:{label:function(t){return[`avg: ${t.raw.avg}`,`max: ${t.raw.max}`,`min: ${t.raw.min}`]}}}}};t(e)[i].datasets[0].backgroundColor=[],t(e)[i].datasets[0].borderColor=[],t(e)[i].datasets[0].data.forEach((function(s,n){t(e)[i].datasets[0].backgroundColor.push(Lr[n]),t(e)[i].datasets[0].borderColor.push(Rr(Lr[n],-50))})),t(e)[i].datasets.length>1&&(t(e)[i].datasets[1].backgroundColor=[],t(e)[i].datasets[1].borderColor=[],t(e)[i].datasets[1].data.forEach((function(s,n){t(e)[i].datasets[1].backgroundColor.push(Rr(Lr[n],-30)),t(e)[i].datasets[1].borderColor.push(Rr(Lr[n],-65))})),n.scales.x={ticks:{callback:function(s,n,o){return[t(e)[i].labels[n],"cold / warm"]}}}),n.plugins.annotation={annotations:{}};for(let s=0;s Array.prototype.slice.call(args));\n let ticking = false;\n let args = [];\n return function(...rest) {\n args = updateArgs(rest);\n if (!ticking) {\n ticking = true;\n requestAnimFrame.call(window, () => {\n ticking = false;\n fn.apply(thisArg, args);\n });\n }\n };\n}\nfunction debounce(fn, delay) {\n let timeout;\n return function(...args) {\n if (delay) {\n clearTimeout(timeout);\n timeout = setTimeout(fn, delay, args);\n } else {\n fn.apply(this, args);\n }\n return delay;\n };\n}\nconst _toLeftRightCenter = (align) => align === 'start' ? 'left' : align === 'end' ? 'right' : 'center';\nconst _alignStartEnd = (align, start, end) => align === 'start' ? start : align === 'end' ? end : (start + end) / 2;\nconst _textX = (align, left, right, rtl) => {\n const check = rtl ? 'left' : 'right';\n return align === check ? right : align === 'center' ? (left + right) / 2 : left;\n};\n\nfunction noop() {}\nconst uid = (function() {\n let id = 0;\n return function() {\n return id++;\n };\n}());\nfunction isNullOrUndef(value) {\n return value === null || typeof value === 'undefined';\n}\nfunction isArray(value) {\n if (Array.isArray && Array.isArray(value)) {\n return true;\n }\n const type = Object.prototype.toString.call(value);\n if (type.slice(0, 7) === '[object' && type.slice(-6) === 'Array]') {\n return true;\n }\n return false;\n}\nfunction isObject(value) {\n return value !== null && Object.prototype.toString.call(value) === '[object Object]';\n}\nconst isNumberFinite = (value) => (typeof value === 'number' || value instanceof Number) && isFinite(+value);\nfunction finiteOrDefault(value, defaultValue) {\n return isNumberFinite(value) ? value : defaultValue;\n}\nfunction valueOrDefault(value, defaultValue) {\n return typeof value === 'undefined' ? defaultValue : value;\n}\nconst toPercentage = (value, dimension) =>\n typeof value === 'string' && value.endsWith('%') ?\n parseFloat(value) / 100\n : value / dimension;\nconst toDimension = (value, dimension) =>\n typeof value === 'string' && value.endsWith('%') ?\n parseFloat(value) / 100 * dimension\n : +value;\nfunction callback(fn, args, thisArg) {\n if (fn && typeof fn.call === 'function') {\n return fn.apply(thisArg, args);\n }\n}\nfunction each(loopable, fn, thisArg, reverse) {\n let i, len, keys;\n if (isArray(loopable)) {\n len = loopable.length;\n if (reverse) {\n for (i = len - 1; i >= 0; i--) {\n fn.call(thisArg, loopable[i], i);\n }\n } else {\n for (i = 0; i < len; i++) {\n fn.call(thisArg, loopable[i], i);\n }\n }\n } else if (isObject(loopable)) {\n keys = Object.keys(loopable);\n len = keys.length;\n for (i = 0; i < len; i++) {\n fn.call(thisArg, loopable[keys[i]], keys[i]);\n }\n }\n}\nfunction _elementsEqual(a0, a1) {\n let i, ilen, v0, v1;\n if (!a0 || !a1 || a0.length !== a1.length) {\n return false;\n }\n for (i = 0, ilen = a0.length; i < ilen; ++i) {\n v0 = a0[i];\n v1 = a1[i];\n if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {\n return false;\n }\n }\n return true;\n}\nfunction clone$1(source) {\n if (isArray(source)) {\n return source.map(clone$1);\n }\n if (isObject(source)) {\n const target = Object.create(null);\n const keys = Object.keys(source);\n const klen = keys.length;\n let k = 0;\n for (; k < klen; ++k) {\n target[keys[k]] = clone$1(source[keys[k]]);\n }\n return target;\n }\n return source;\n}\nfunction isValidKey(key) {\n return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1;\n}\nfunction _merger(key, target, source, options) {\n if (!isValidKey(key)) {\n return;\n }\n const tval = target[key];\n const sval = source[key];\n if (isObject(tval) && isObject(sval)) {\n merge(tval, sval, options);\n } else {\n target[key] = clone$1(sval);\n }\n}\nfunction merge(target, source, options) {\n const sources = isArray(source) ? source : [source];\n const ilen = sources.length;\n if (!isObject(target)) {\n return target;\n }\n options = options || {};\n const merger = options.merger || _merger;\n for (let i = 0; i < ilen; ++i) {\n source = sources[i];\n if (!isObject(source)) {\n continue;\n }\n const keys = Object.keys(source);\n for (let k = 0, klen = keys.length; k < klen; ++k) {\n merger(keys[k], target, source, options);\n }\n }\n return target;\n}\nfunction mergeIf(target, source) {\n return merge(target, source, {merger: _mergerIf});\n}\nfunction _mergerIf(key, target, source) {\n if (!isValidKey(key)) {\n return;\n }\n const tval = target[key];\n const sval = source[key];\n if (isObject(tval) && isObject(sval)) {\n mergeIf(tval, sval);\n } else if (!Object.prototype.hasOwnProperty.call(target, key)) {\n target[key] = clone$1(sval);\n }\n}\nfunction _deprecated(scope, value, previous, current) {\n if (value !== undefined) {\n console.warn(scope + ': \"' + previous +\n\t\t\t'\" is deprecated. Please use \"' + current + '\" instead');\n }\n}\nconst emptyString = '';\nconst dot = '.';\nfunction indexOfDotOrLength(key, start) {\n const idx = key.indexOf(dot, start);\n return idx === -1 ? key.length : idx;\n}\nfunction resolveObjectKey(obj, key) {\n if (key === emptyString) {\n return obj;\n }\n let pos = 0;\n let idx = indexOfDotOrLength(key, pos);\n while (obj && idx > pos) {\n obj = obj[key.slice(pos, idx)];\n pos = idx + 1;\n idx = indexOfDotOrLength(key, pos);\n }\n return obj;\n}\nfunction _capitalize(str) {\n return str.charAt(0).toUpperCase() + str.slice(1);\n}\nconst defined = (value) => typeof value !== 'undefined';\nconst isFunction = (value) => typeof value === 'function';\nconst setsEqual = (a, b) => {\n if (a.size !== b.size) {\n return false;\n }\n for (const item of a) {\n if (!b.has(item)) {\n return false;\n }\n }\n return true;\n};\nfunction _isClickEvent(e) {\n return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu';\n}\n\nconst PI = Math.PI;\nconst TAU = 2 * PI;\nconst PITAU = TAU + PI;\nconst INFINITY = Number.POSITIVE_INFINITY;\nconst RAD_PER_DEG = PI / 180;\nconst HALF_PI = PI / 2;\nconst QUARTER_PI = PI / 4;\nconst TWO_THIRDS_PI = PI * 2 / 3;\nconst log10 = Math.log10;\nconst sign = Math.sign;\nfunction niceNum(range) {\n const roundedRange = Math.round(range);\n range = almostEquals(range, roundedRange, range / 1000) ? roundedRange : range;\n const niceRange = Math.pow(10, Math.floor(log10(range)));\n const fraction = range / niceRange;\n const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;\n return niceFraction * niceRange;\n}\nfunction _factorize(value) {\n const result = [];\n const sqrt = Math.sqrt(value);\n let i;\n for (i = 1; i < sqrt; i++) {\n if (value % i === 0) {\n result.push(i);\n result.push(value / i);\n }\n }\n if (sqrt === (sqrt | 0)) {\n result.push(sqrt);\n }\n result.sort((a, b) => a - b).pop();\n return result;\n}\nfunction isNumber(n) {\n return !isNaN(parseFloat(n)) && isFinite(n);\n}\nfunction almostEquals(x, y, epsilon) {\n return Math.abs(x - y) < epsilon;\n}\nfunction almostWhole(x, epsilon) {\n const rounded = Math.round(x);\n return ((rounded - epsilon) <= x) && ((rounded + epsilon) >= x);\n}\nfunction _setMinAndMaxByKey(array, target, property) {\n let i, ilen, value;\n for (i = 0, ilen = array.length; i < ilen; i++) {\n value = array[i][property];\n if (!isNaN(value)) {\n target.min = Math.min(target.min, value);\n target.max = Math.max(target.max, value);\n }\n }\n}\nfunction toRadians(degrees) {\n return degrees * (PI / 180);\n}\nfunction toDegrees(radians) {\n return radians * (180 / PI);\n}\nfunction _decimalPlaces(x) {\n if (!isNumberFinite(x)) {\n return;\n }\n let e = 1;\n let p = 0;\n while (Math.round(x * e) / e !== x) {\n e *= 10;\n p++;\n }\n return p;\n}\nfunction getAngleFromPoint(centrePoint, anglePoint) {\n const distanceFromXCenter = anglePoint.x - centrePoint.x;\n const distanceFromYCenter = anglePoint.y - centrePoint.y;\n const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);\n let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);\n if (angle < (-0.5 * PI)) {\n angle += TAU;\n }\n return {\n angle,\n distance: radialDistanceFromCenter\n };\n}\nfunction distanceBetweenPoints(pt1, pt2) {\n return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));\n}\nfunction _angleDiff(a, b) {\n return (a - b + PITAU) % TAU - PI;\n}\nfunction _normalizeAngle(a) {\n return (a % TAU + TAU) % TAU;\n}\nfunction _angleBetween(angle, start, end, sameAngleIsFullCircle) {\n const a = _normalizeAngle(angle);\n const s = _normalizeAngle(start);\n const e = _normalizeAngle(end);\n const angleToStart = _normalizeAngle(s - a);\n const angleToEnd = _normalizeAngle(e - a);\n const startToAngle = _normalizeAngle(a - s);\n const endToAngle = _normalizeAngle(a - e);\n return a === s || a === e || (sameAngleIsFullCircle && s === e)\n || (angleToStart > angleToEnd && startToAngle < endToAngle);\n}\nfunction _limitValue(value, min, max) {\n return Math.max(min, Math.min(max, value));\n}\nfunction _int16Range(value) {\n return _limitValue(value, -32768, 32767);\n}\nfunction _isBetween(value, start, end, epsilon = 1e-6) {\n return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;\n}\n\nconst atEdge = (t) => t === 0 || t === 1;\nconst elasticIn = (t, s, p) => -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p));\nconst elasticOut = (t, s, p) => Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1;\nconst effects = {\n linear: t => t,\n easeInQuad: t => t * t,\n easeOutQuad: t => -t * (t - 2),\n easeInOutQuad: t => ((t /= 0.5) < 1)\n ? 0.5 * t * t\n : -0.5 * ((--t) * (t - 2) - 1),\n easeInCubic: t => t * t * t,\n easeOutCubic: t => (t -= 1) * t * t + 1,\n easeInOutCubic: t => ((t /= 0.5) < 1)\n ? 0.5 * t * t * t\n : 0.5 * ((t -= 2) * t * t + 2),\n easeInQuart: t => t * t * t * t,\n easeOutQuart: t => -((t -= 1) * t * t * t - 1),\n easeInOutQuart: t => ((t /= 0.5) < 1)\n ? 0.5 * t * t * t * t\n : -0.5 * ((t -= 2) * t * t * t - 2),\n easeInQuint: t => t * t * t * t * t,\n easeOutQuint: t => (t -= 1) * t * t * t * t + 1,\n easeInOutQuint: t => ((t /= 0.5) < 1)\n ? 0.5 * t * t * t * t * t\n : 0.5 * ((t -= 2) * t * t * t * t + 2),\n easeInSine: t => -Math.cos(t * HALF_PI) + 1,\n easeOutSine: t => Math.sin(t * HALF_PI),\n easeInOutSine: t => -0.5 * (Math.cos(PI * t) - 1),\n easeInExpo: t => (t === 0) ? 0 : Math.pow(2, 10 * (t - 1)),\n easeOutExpo: t => (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1,\n easeInOutExpo: t => atEdge(t) ? t : t < 0.5\n ? 0.5 * Math.pow(2, 10 * (t * 2 - 1))\n : 0.5 * (-Math.pow(2, -10 * (t * 2 - 1)) + 2),\n easeInCirc: t => (t >= 1) ? t : -(Math.sqrt(1 - t * t) - 1),\n easeOutCirc: t => Math.sqrt(1 - (t -= 1) * t),\n easeInOutCirc: t => ((t /= 0.5) < 1)\n ? -0.5 * (Math.sqrt(1 - t * t) - 1)\n : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1),\n easeInElastic: t => atEdge(t) ? t : elasticIn(t, 0.075, 0.3),\n easeOutElastic: t => atEdge(t) ? t : elasticOut(t, 0.075, 0.3),\n easeInOutElastic(t) {\n const s = 0.1125;\n const p = 0.45;\n return atEdge(t) ? t :\n t < 0.5\n ? 0.5 * elasticIn(t * 2, s, p)\n : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p);\n },\n easeInBack(t) {\n const s = 1.70158;\n return t * t * ((s + 1) * t - s);\n },\n easeOutBack(t) {\n const s = 1.70158;\n return (t -= 1) * t * ((s + 1) * t + s) + 1;\n },\n easeInOutBack(t) {\n let s = 1.70158;\n if ((t /= 0.5) < 1) {\n return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s));\n }\n return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2);\n },\n easeInBounce: t => 1 - effects.easeOutBounce(1 - t),\n easeOutBounce(t) {\n const m = 7.5625;\n const d = 2.75;\n if (t < (1 / d)) {\n return m * t * t;\n }\n if (t < (2 / d)) {\n return m * (t -= (1.5 / d)) * t + 0.75;\n }\n if (t < (2.5 / d)) {\n return m * (t -= (2.25 / d)) * t + 0.9375;\n }\n return m * (t -= (2.625 / d)) * t + 0.984375;\n },\n easeInOutBounce: t => (t < 0.5)\n ? effects.easeInBounce(t * 2) * 0.5\n : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5,\n};\n\n/*!\n * @kurkle/color v0.2.1\n * https://github.com/kurkle/color#readme\n * (c) 2022 Jukka Kurkela\n * Released under the MIT License\n */\nfunction round(v) {\n return v + 0.5 | 0;\n}\nconst lim = (v, l, h) => Math.max(Math.min(v, h), l);\nfunction p2b(v) {\n return lim(round(v * 2.55), 0, 255);\n}\nfunction n2b(v) {\n return lim(round(v * 255), 0, 255);\n}\nfunction b2n(v) {\n return lim(round(v / 2.55) / 100, 0, 1);\n}\nfunction n2p(v) {\n return lim(round(v * 100), 0, 100);\n}\nconst map$1 = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15};\nconst hex = [...'0123456789ABCDEF'];\nconst h1 = b => hex[b & 0xF];\nconst h2 = b => hex[(b & 0xF0) >> 4] + hex[b & 0xF];\nconst eq = b => ((b & 0xF0) >> 4) === (b & 0xF);\nconst isShort = v => eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a);\nfunction hexParse(str) {\n var len = str.length;\n var ret;\n if (str[0] === '#') {\n if (len === 4 || len === 5) {\n ret = {\n r: 255 & map$1[str[1]] * 17,\n g: 255 & map$1[str[2]] * 17,\n b: 255 & map$1[str[3]] * 17,\n a: len === 5 ? map$1[str[4]] * 17 : 255\n };\n } else if (len === 7 || len === 9) {\n ret = {\n r: map$1[str[1]] << 4 | map$1[str[2]],\n g: map$1[str[3]] << 4 | map$1[str[4]],\n b: map$1[str[5]] << 4 | map$1[str[6]],\n a: len === 9 ? (map$1[str[7]] << 4 | map$1[str[8]]) : 255\n };\n }\n }\n return ret;\n}\nconst alpha = (a, f) => a < 255 ? f(a) : '';\nfunction hexString(v) {\n var f = isShort(v) ? h1 : h2;\n return v\n ? '#' + f(v.r) + f(v.g) + f(v.b) + alpha(v.a, f)\n : undefined;\n}\nconst HUE_RE = /^(hsla?|hwb|hsv)\\(\\s*([-+.e\\d]+)(?:deg)?[\\s,]+([-+.e\\d]+)%[\\s,]+([-+.e\\d]+)%(?:[\\s,]+([-+.e\\d]+)(%)?)?\\s*\\)$/;\nfunction hsl2rgbn(h, s, l) {\n const a = s * Math.min(l, 1 - l);\n const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);\n return [f(0), f(8), f(4)];\n}\nfunction hsv2rgbn(h, s, v) {\n const f = (n, k = (n + h / 60) % 6) => v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);\n return [f(5), f(3), f(1)];\n}\nfunction hwb2rgbn(h, w, b) {\n const rgb = hsl2rgbn(h, 1, 0.5);\n let i;\n if (w + b > 1) {\n i = 1 / (w + b);\n w *= i;\n b *= i;\n }\n for (i = 0; i < 3; i++) {\n rgb[i] *= 1 - w - b;\n rgb[i] += w;\n }\n return rgb;\n}\nfunction hueValue(r, g, b, d, max) {\n if (r === max) {\n return ((g - b) / d) + (g < b ? 6 : 0);\n }\n if (g === max) {\n return (b - r) / d + 2;\n }\n return (r - g) / d + 4;\n}\nfunction rgb2hsl(v) {\n const range = 255;\n const r = v.r / range;\n const g = v.g / range;\n const b = v.b / range;\n const max = Math.max(r, g, b);\n const min = Math.min(r, g, b);\n const l = (max + min) / 2;\n let h, s, d;\n if (max !== min) {\n d = max - min;\n s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n h = hueValue(r, g, b, d, max);\n h = h * 60 + 0.5;\n }\n return [h | 0, s || 0, l];\n}\nfunction calln(f, a, b, c) {\n return (\n Array.isArray(a)\n ? f(a[0], a[1], a[2])\n : f(a, b, c)\n ).map(n2b);\n}\nfunction hsl2rgb(h, s, l) {\n return calln(hsl2rgbn, h, s, l);\n}\nfunction hwb2rgb(h, w, b) {\n return calln(hwb2rgbn, h, w, b);\n}\nfunction hsv2rgb(h, s, v) {\n return calln(hsv2rgbn, h, s, v);\n}\nfunction hue(h) {\n return (h % 360 + 360) % 360;\n}\nfunction hueParse(str) {\n const m = HUE_RE.exec(str);\n let a = 255;\n let v;\n if (!m) {\n return;\n }\n if (m[5] !== v) {\n a = m[6] ? p2b(+m[5]) : n2b(+m[5]);\n }\n const h = hue(+m[2]);\n const p1 = +m[3] / 100;\n const p2 = +m[4] / 100;\n if (m[1] === 'hwb') {\n v = hwb2rgb(h, p1, p2);\n } else if (m[1] === 'hsv') {\n v = hsv2rgb(h, p1, p2);\n } else {\n v = hsl2rgb(h, p1, p2);\n }\n return {\n r: v[0],\n g: v[1],\n b: v[2],\n a: a\n };\n}\nfunction rotate(v, deg) {\n var h = rgb2hsl(v);\n h[0] = hue(h[0] + deg);\n h = hsl2rgb(h);\n v.r = h[0];\n v.g = h[1];\n v.b = h[2];\n}\nfunction hslString(v) {\n if (!v) {\n return;\n }\n const a = rgb2hsl(v);\n const h = a[0];\n const s = n2p(a[1]);\n const l = n2p(a[2]);\n return v.a < 255\n ? `hsla(${h}, ${s}%, ${l}%, ${b2n(v.a)})`\n : `hsl(${h}, ${s}%, ${l}%)`;\n}\nconst map = {\n x: 'dark',\n Z: 'light',\n Y: 're',\n X: 'blu',\n W: 'gr',\n V: 'medium',\n U: 'slate',\n A: 'ee',\n T: 'ol',\n S: 'or',\n B: 'ra',\n C: 'lateg',\n D: 'ights',\n R: 'in',\n Q: 'turquois',\n E: 'hi',\n P: 'ro',\n O: 'al',\n N: 'le',\n M: 'de',\n L: 'yello',\n F: 'en',\n K: 'ch',\n G: 'arks',\n H: 'ea',\n I: 'ightg',\n J: 'wh'\n};\nconst names$1 = {\n OiceXe: 'f0f8ff',\n antiquewEte: 'faebd7',\n aqua: 'ffff',\n aquamarRe: '7fffd4',\n azuY: 'f0ffff',\n beige: 'f5f5dc',\n bisque: 'ffe4c4',\n black: '0',\n blanKedOmond: 'ffebcd',\n Xe: 'ff',\n XeviTet: '8a2be2',\n bPwn: 'a52a2a',\n burlywood: 'deb887',\n caMtXe: '5f9ea0',\n KartYuse: '7fff00',\n KocTate: 'd2691e',\n cSO: 'ff7f50',\n cSnflowerXe: '6495ed',\n cSnsilk: 'fff8dc',\n crimson: 'dc143c',\n cyan: 'ffff',\n xXe: '8b',\n xcyan: '8b8b',\n xgTMnPd: 'b8860b',\n xWay: 'a9a9a9',\n xgYF: '6400',\n xgYy: 'a9a9a9',\n xkhaki: 'bdb76b',\n xmagFta: '8b008b',\n xTivegYF: '556b2f',\n xSange: 'ff8c00',\n xScEd: '9932cc',\n xYd: '8b0000',\n xsOmon: 'e9967a',\n xsHgYF: '8fbc8f',\n xUXe: '483d8b',\n xUWay: '2f4f4f',\n xUgYy: '2f4f4f',\n xQe: 'ced1',\n xviTet: '9400d3',\n dAppRk: 'ff1493',\n dApskyXe: 'bfff',\n dimWay: '696969',\n dimgYy: '696969',\n dodgerXe: '1e90ff',\n fiYbrick: 'b22222',\n flSOwEte: 'fffaf0',\n foYstWAn: '228b22',\n fuKsia: 'ff00ff',\n gaRsbSo: 'dcdcdc',\n ghostwEte: 'f8f8ff',\n gTd: 'ffd700',\n gTMnPd: 'daa520',\n Way: '808080',\n gYF: '8000',\n gYFLw: 'adff2f',\n gYy: '808080',\n honeyMw: 'f0fff0',\n hotpRk: 'ff69b4',\n RdianYd: 'cd5c5c',\n Rdigo: '4b0082',\n ivSy: 'fffff0',\n khaki: 'f0e68c',\n lavFMr: 'e6e6fa',\n lavFMrXsh: 'fff0f5',\n lawngYF: '7cfc00',\n NmoncEffon: 'fffacd',\n ZXe: 'add8e6',\n ZcSO: 'f08080',\n Zcyan: 'e0ffff',\n ZgTMnPdLw: 'fafad2',\n ZWay: 'd3d3d3',\n ZgYF: '90ee90',\n ZgYy: 'd3d3d3',\n ZpRk: 'ffb6c1',\n ZsOmon: 'ffa07a',\n ZsHgYF: '20b2aa',\n ZskyXe: '87cefa',\n ZUWay: '778899',\n ZUgYy: '778899',\n ZstAlXe: 'b0c4de',\n ZLw: 'ffffe0',\n lime: 'ff00',\n limegYF: '32cd32',\n lRF: 'faf0e6',\n magFta: 'ff00ff',\n maPon: '800000',\n VaquamarRe: '66cdaa',\n VXe: 'cd',\n VScEd: 'ba55d3',\n VpurpN: '9370db',\n VsHgYF: '3cb371',\n VUXe: '7b68ee',\n VsprRggYF: 'fa9a',\n VQe: '48d1cc',\n VviTetYd: 'c71585',\n midnightXe: '191970',\n mRtcYam: 'f5fffa',\n mistyPse: 'ffe4e1',\n moccasR: 'ffe4b5',\n navajowEte: 'ffdead',\n navy: '80',\n Tdlace: 'fdf5e6',\n Tive: '808000',\n TivedBb: '6b8e23',\n Sange: 'ffa500',\n SangeYd: 'ff4500',\n ScEd: 'da70d6',\n pOegTMnPd: 'eee8aa',\n pOegYF: '98fb98',\n pOeQe: 'afeeee',\n pOeviTetYd: 'db7093',\n papayawEp: 'ffefd5',\n pHKpuff: 'ffdab9',\n peru: 'cd853f',\n pRk: 'ffc0cb',\n plum: 'dda0dd',\n powMrXe: 'b0e0e6',\n purpN: '800080',\n YbeccapurpN: '663399',\n Yd: 'ff0000',\n Psybrown: 'bc8f8f',\n PyOXe: '4169e1',\n saddNbPwn: '8b4513',\n sOmon: 'fa8072',\n sandybPwn: 'f4a460',\n sHgYF: '2e8b57',\n sHshell: 'fff5ee',\n siFna: 'a0522d',\n silver: 'c0c0c0',\n skyXe: '87ceeb',\n UXe: '6a5acd',\n UWay: '708090',\n UgYy: '708090',\n snow: 'fffafa',\n sprRggYF: 'ff7f',\n stAlXe: '4682b4',\n tan: 'd2b48c',\n teO: '8080',\n tEstN: 'd8bfd8',\n tomato: 'ff6347',\n Qe: '40e0d0',\n viTet: 'ee82ee',\n JHt: 'f5deb3',\n wEte: 'ffffff',\n wEtesmoke: 'f5f5f5',\n Lw: 'ffff00',\n LwgYF: '9acd32'\n};\nfunction unpack() {\n const unpacked = {};\n const keys = Object.keys(names$1);\n const tkeys = Object.keys(map);\n let i, j, k, ok, nk;\n for (i = 0; i < keys.length; i++) {\n ok = nk = keys[i];\n for (j = 0; j < tkeys.length; j++) {\n k = tkeys[j];\n nk = nk.replace(k, map[k]);\n }\n k = parseInt(names$1[ok], 16);\n unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF];\n }\n return unpacked;\n}\nlet names;\nfunction nameParse(str) {\n if (!names) {\n names = unpack();\n names.transparent = [0, 0, 0, 0];\n }\n const a = names[str.toLowerCase()];\n return a && {\n r: a[0],\n g: a[1],\n b: a[2],\n a: a.length === 4 ? a[3] : 255\n };\n}\nconst RGB_RE = /^rgba?\\(\\s*([-+.\\d]+)(%)?[\\s,]+([-+.e\\d]+)(%)?[\\s,]+([-+.e\\d]+)(%)?(?:[\\s,/]+([-+.e\\d]+)(%)?)?\\s*\\)$/;\nfunction rgbParse(str) {\n const m = RGB_RE.exec(str);\n let a = 255;\n let r, g, b;\n if (!m) {\n return;\n }\n if (m[7] !== r) {\n const v = +m[7];\n a = m[8] ? p2b(v) : lim(v * 255, 0, 255);\n }\n r = +m[1];\n g = +m[3];\n b = +m[5];\n r = 255 & (m[2] ? p2b(r) : lim(r, 0, 255));\n g = 255 & (m[4] ? p2b(g) : lim(g, 0, 255));\n b = 255 & (m[6] ? p2b(b) : lim(b, 0, 255));\n return {\n r: r,\n g: g,\n b: b,\n a: a\n };\n}\nfunction rgbString(v) {\n return v && (\n v.a < 255\n ? `rgba(${v.r}, ${v.g}, ${v.b}, ${b2n(v.a)})`\n : `rgb(${v.r}, ${v.g}, ${v.b})`\n );\n}\nconst to = v => v <= 0.0031308 ? v * 12.92 : Math.pow(v, 1.0 / 2.4) * 1.055 - 0.055;\nconst from = v => v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);\nfunction interpolate(rgb1, rgb2, t) {\n const r = from(b2n(rgb1.r));\n const g = from(b2n(rgb1.g));\n const b = from(b2n(rgb1.b));\n return {\n r: n2b(to(r + t * (from(b2n(rgb2.r)) - r))),\n g: n2b(to(g + t * (from(b2n(rgb2.g)) - g))),\n b: n2b(to(b + t * (from(b2n(rgb2.b)) - b))),\n a: rgb1.a + t * (rgb2.a - rgb1.a)\n };\n}\nfunction modHSL(v, i, ratio) {\n if (v) {\n let tmp = rgb2hsl(v);\n tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1));\n tmp = hsl2rgb(tmp);\n v.r = tmp[0];\n v.g = tmp[1];\n v.b = tmp[2];\n }\n}\nfunction clone(v, proto) {\n return v ? Object.assign(proto || {}, v) : v;\n}\nfunction fromObject(input) {\n var v = {r: 0, g: 0, b: 0, a: 255};\n if (Array.isArray(input)) {\n if (input.length >= 3) {\n v = {r: input[0], g: input[1], b: input[2], a: 255};\n if (input.length > 3) {\n v.a = n2b(input[3]);\n }\n }\n } else {\n v = clone(input, {r: 0, g: 0, b: 0, a: 1});\n v.a = n2b(v.a);\n }\n return v;\n}\nfunction functionParse(str) {\n if (str.charAt(0) === 'r') {\n return rgbParse(str);\n }\n return hueParse(str);\n}\nclass Color {\n constructor(input) {\n if (input instanceof Color) {\n return input;\n }\n const type = typeof input;\n let v;\n if (type === 'object') {\n v = fromObject(input);\n } else if (type === 'string') {\n v = hexParse(input) || nameParse(input) || functionParse(input);\n }\n this._rgb = v;\n this._valid = !!v;\n }\n get valid() {\n return this._valid;\n }\n get rgb() {\n var v = clone(this._rgb);\n if (v) {\n v.a = b2n(v.a);\n }\n return v;\n }\n set rgb(obj) {\n this._rgb = fromObject(obj);\n }\n rgbString() {\n return this._valid ? rgbString(this._rgb) : undefined;\n }\n hexString() {\n return this._valid ? hexString(this._rgb) : undefined;\n }\n hslString() {\n return this._valid ? hslString(this._rgb) : undefined;\n }\n mix(color, weight) {\n if (color) {\n const c1 = this.rgb;\n const c2 = color.rgb;\n let w2;\n const p = weight === w2 ? 0.5 : weight;\n const w = 2 * p - 1;\n const a = c1.a - c2.a;\n const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0;\n w2 = 1 - w1;\n c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5;\n c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5;\n c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5;\n c1.a = p * c1.a + (1 - p) * c2.a;\n this.rgb = c1;\n }\n return this;\n }\n interpolate(color, t) {\n if (color) {\n this._rgb = interpolate(this._rgb, color._rgb, t);\n }\n return this;\n }\n clone() {\n return new Color(this.rgb);\n }\n alpha(a) {\n this._rgb.a = n2b(a);\n return this;\n }\n clearer(ratio) {\n const rgb = this._rgb;\n rgb.a *= 1 - ratio;\n return this;\n }\n greyscale() {\n const rgb = this._rgb;\n const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11);\n rgb.r = rgb.g = rgb.b = val;\n return this;\n }\n opaquer(ratio) {\n const rgb = this._rgb;\n rgb.a *= 1 + ratio;\n return this;\n }\n negate() {\n const v = this._rgb;\n v.r = 255 - v.r;\n v.g = 255 - v.g;\n v.b = 255 - v.b;\n return this;\n }\n lighten(ratio) {\n modHSL(this._rgb, 2, ratio);\n return this;\n }\n darken(ratio) {\n modHSL(this._rgb, 2, -ratio);\n return this;\n }\n saturate(ratio) {\n modHSL(this._rgb, 1, ratio);\n return this;\n }\n desaturate(ratio) {\n modHSL(this._rgb, 1, -ratio);\n return this;\n }\n rotate(deg) {\n rotate(this._rgb, deg);\n return this;\n }\n}\nfunction index_esm(input) {\n return new Color(input);\n}\n\nfunction isPatternOrGradient(value) {\n if (value && typeof value === 'object') {\n const type = value.toString();\n return type === '[object CanvasPattern]' || type === '[object CanvasGradient]';\n }\n return false;\n}\nfunction color(value) {\n return isPatternOrGradient(value) ? value : index_esm(value);\n}\nfunction getHoverColor(value) {\n return isPatternOrGradient(value)\n ? value\n : index_esm(value).saturate(0.5).darken(0.1).hexString();\n}\n\nconst overrides = Object.create(null);\nconst descriptors = Object.create(null);\nfunction getScope$1(node, key) {\n if (!key) {\n return node;\n }\n const keys = key.split('.');\n for (let i = 0, n = keys.length; i < n; ++i) {\n const k = keys[i];\n node = node[k] || (node[k] = Object.create(null));\n }\n return node;\n}\nfunction set(root, scope, values) {\n if (typeof scope === 'string') {\n return merge(getScope$1(root, scope), values);\n }\n return merge(getScope$1(root, ''), scope);\n}\nclass Defaults {\n constructor(_descriptors) {\n this.animation = undefined;\n this.backgroundColor = 'rgba(0,0,0,0.1)';\n this.borderColor = 'rgba(0,0,0,0.1)';\n this.color = '#666';\n this.datasets = {};\n this.devicePixelRatio = (context) => context.chart.platform.getDevicePixelRatio();\n this.elements = {};\n this.events = [\n 'mousemove',\n 'mouseout',\n 'click',\n 'touchstart',\n 'touchmove'\n ];\n this.font = {\n family: \"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif\",\n size: 12,\n style: 'normal',\n lineHeight: 1.2,\n weight: null\n };\n this.hover = {};\n this.hoverBackgroundColor = (ctx, options) => getHoverColor(options.backgroundColor);\n this.hoverBorderColor = (ctx, options) => getHoverColor(options.borderColor);\n this.hoverColor = (ctx, options) => getHoverColor(options.color);\n this.indexAxis = 'x';\n this.interaction = {\n mode: 'nearest',\n intersect: true,\n includeInvisible: false\n };\n this.maintainAspectRatio = true;\n this.onHover = null;\n this.onClick = null;\n this.parsing = true;\n this.plugins = {};\n this.responsive = true;\n this.scale = undefined;\n this.scales = {};\n this.showLine = true;\n this.drawActiveElementsOnTop = true;\n this.describe(_descriptors);\n }\n set(scope, values) {\n return set(this, scope, values);\n }\n get(scope) {\n return getScope$1(this, scope);\n }\n describe(scope, values) {\n return set(descriptors, scope, values);\n }\n override(scope, values) {\n return set(overrides, scope, values);\n }\n route(scope, name, targetScope, targetName) {\n const scopeObject = getScope$1(this, scope);\n const targetScopeObject = getScope$1(this, targetScope);\n const privateName = '_' + name;\n Object.defineProperties(scopeObject, {\n [privateName]: {\n value: scopeObject[name],\n writable: true\n },\n [name]: {\n enumerable: true,\n get() {\n const local = this[privateName];\n const target = targetScopeObject[targetName];\n if (isObject(local)) {\n return Object.assign({}, target, local);\n }\n return valueOrDefault(local, target);\n },\n set(value) {\n this[privateName] = value;\n }\n }\n });\n }\n}\nvar defaults = new Defaults({\n _scriptable: (name) => !name.startsWith('on'),\n _indexable: (name) => name !== 'events',\n hover: {\n _fallback: 'interaction'\n },\n interaction: {\n _scriptable: false,\n _indexable: false,\n }\n});\n\nfunction toFontString(font) {\n if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {\n return null;\n }\n return (font.style ? font.style + ' ' : '')\n\t\t+ (font.weight ? font.weight + ' ' : '')\n\t\t+ font.size + 'px '\n\t\t+ font.family;\n}\nfunction _measureText(ctx, data, gc, longest, string) {\n let textWidth = data[string];\n if (!textWidth) {\n textWidth = data[string] = ctx.measureText(string).width;\n gc.push(string);\n }\n if (textWidth > longest) {\n longest = textWidth;\n }\n return longest;\n}\nfunction _longestText(ctx, font, arrayOfThings, cache) {\n cache = cache || {};\n let data = cache.data = cache.data || {};\n let gc = cache.garbageCollect = cache.garbageCollect || [];\n if (cache.font !== font) {\n data = cache.data = {};\n gc = cache.garbageCollect = [];\n cache.font = font;\n }\n ctx.save();\n ctx.font = font;\n let longest = 0;\n const ilen = arrayOfThings.length;\n let i, j, jlen, thing, nestedThing;\n for (i = 0; i < ilen; i++) {\n thing = arrayOfThings[i];\n if (thing !== undefined && thing !== null && isArray(thing) !== true) {\n longest = _measureText(ctx, data, gc, longest, thing);\n } else if (isArray(thing)) {\n for (j = 0, jlen = thing.length; j < jlen; j++) {\n nestedThing = thing[j];\n if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) {\n longest = _measureText(ctx, data, gc, longest, nestedThing);\n }\n }\n }\n }\n ctx.restore();\n const gcLen = gc.length / 2;\n if (gcLen > arrayOfThings.length) {\n for (i = 0; i < gcLen; i++) {\n delete data[gc[i]];\n }\n gc.splice(0, gcLen);\n }\n return longest;\n}\nfunction _alignPixel(chart, pixel, width) {\n const devicePixelRatio = chart.currentDevicePixelRatio;\n const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;\n return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;\n}\nfunction clearCanvas(canvas, ctx) {\n ctx = ctx || canvas.getContext('2d');\n ctx.save();\n ctx.resetTransform();\n ctx.clearRect(0, 0, canvas.width, canvas.height);\n ctx.restore();\n}\nfunction drawPoint(ctx, options, x, y) {\n let type, xOffset, yOffset, size, cornerRadius;\n const style = options.pointStyle;\n const rotation = options.rotation;\n const radius = options.radius;\n let rad = (rotation || 0) * RAD_PER_DEG;\n if (style && typeof style === 'object') {\n type = style.toString();\n if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {\n ctx.save();\n ctx.translate(x, y);\n ctx.rotate(rad);\n ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);\n ctx.restore();\n return;\n }\n }\n if (isNaN(radius) || radius <= 0) {\n return;\n }\n ctx.beginPath();\n switch (style) {\n default:\n ctx.arc(x, y, radius, 0, TAU);\n ctx.closePath();\n break;\n case 'triangle':\n ctx.moveTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);\n rad += TWO_THIRDS_PI;\n ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);\n rad += TWO_THIRDS_PI;\n ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius);\n ctx.closePath();\n break;\n case 'rectRounded':\n cornerRadius = radius * 0.516;\n size = radius - cornerRadius;\n xOffset = Math.cos(rad + QUARTER_PI) * size;\n yOffset = Math.sin(rad + QUARTER_PI) * size;\n ctx.arc(x - xOffset, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI);\n ctx.arc(x + yOffset, y - xOffset, cornerRadius, rad - HALF_PI, rad);\n ctx.arc(x + xOffset, y + yOffset, cornerRadius, rad, rad + HALF_PI);\n ctx.arc(x - yOffset, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI);\n ctx.closePath();\n break;\n case 'rect':\n if (!rotation) {\n size = Math.SQRT1_2 * radius;\n ctx.rect(x - size, y - size, 2 * size, 2 * size);\n break;\n }\n rad += QUARTER_PI;\n case 'rectRot':\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + yOffset, y - xOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n ctx.lineTo(x - yOffset, y + xOffset);\n ctx.closePath();\n break;\n case 'crossRot':\n rad += QUARTER_PI;\n case 'cross':\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n ctx.moveTo(x + yOffset, y - xOffset);\n ctx.lineTo(x - yOffset, y + xOffset);\n break;\n case 'star':\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n ctx.moveTo(x + yOffset, y - xOffset);\n ctx.lineTo(x - yOffset, y + xOffset);\n rad += QUARTER_PI;\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n ctx.moveTo(x + yOffset, y - xOffset);\n ctx.lineTo(x - yOffset, y + xOffset);\n break;\n case 'line':\n xOffset = Math.cos(rad) * radius;\n yOffset = Math.sin(rad) * radius;\n ctx.moveTo(x - xOffset, y - yOffset);\n ctx.lineTo(x + xOffset, y + yOffset);\n break;\n case 'dash':\n ctx.moveTo(x, y);\n ctx.lineTo(x + Math.cos(rad) * radius, y + Math.sin(rad) * radius);\n break;\n }\n ctx.fill();\n if (options.borderWidth > 0) {\n ctx.stroke();\n }\n}\nfunction _isPointInArea(point, area, margin) {\n margin = margin || 0.5;\n return !area || (point && point.x > area.left - margin && point.x < area.right + margin &&\n\t\tpoint.y > area.top - margin && point.y < area.bottom + margin);\n}\nfunction clipArea(ctx, area) {\n ctx.save();\n ctx.beginPath();\n ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);\n ctx.clip();\n}\nfunction unclipArea(ctx) {\n ctx.restore();\n}\nfunction _steppedLineTo(ctx, previous, target, flip, mode) {\n if (!previous) {\n return ctx.lineTo(target.x, target.y);\n }\n if (mode === 'middle') {\n const midpoint = (previous.x + target.x) / 2.0;\n ctx.lineTo(midpoint, previous.y);\n ctx.lineTo(midpoint, target.y);\n } else if (mode === 'after' !== !!flip) {\n ctx.lineTo(previous.x, target.y);\n } else {\n ctx.lineTo(target.x, previous.y);\n }\n ctx.lineTo(target.x, target.y);\n}\nfunction _bezierCurveTo(ctx, previous, target, flip) {\n if (!previous) {\n return ctx.lineTo(target.x, target.y);\n }\n ctx.bezierCurveTo(\n flip ? previous.cp1x : previous.cp2x,\n flip ? previous.cp1y : previous.cp2y,\n flip ? target.cp2x : target.cp1x,\n flip ? target.cp2y : target.cp1y,\n target.x,\n target.y);\n}\nfunction renderText(ctx, text, x, y, font, opts = {}) {\n const lines = isArray(text) ? text : [text];\n const stroke = opts.strokeWidth > 0 && opts.strokeColor !== '';\n let i, line;\n ctx.save();\n ctx.font = font.string;\n setRenderOpts(ctx, opts);\n for (i = 0; i < lines.length; ++i) {\n line = lines[i];\n if (stroke) {\n if (opts.strokeColor) {\n ctx.strokeStyle = opts.strokeColor;\n }\n if (!isNullOrUndef(opts.strokeWidth)) {\n ctx.lineWidth = opts.strokeWidth;\n }\n ctx.strokeText(line, x, y, opts.maxWidth);\n }\n ctx.fillText(line, x, y, opts.maxWidth);\n decorateText(ctx, x, y, line, opts);\n y += font.lineHeight;\n }\n ctx.restore();\n}\nfunction setRenderOpts(ctx, opts) {\n if (opts.translation) {\n ctx.translate(opts.translation[0], opts.translation[1]);\n }\n if (!isNullOrUndef(opts.rotation)) {\n ctx.rotate(opts.rotation);\n }\n if (opts.color) {\n ctx.fillStyle = opts.color;\n }\n if (opts.textAlign) {\n ctx.textAlign = opts.textAlign;\n }\n if (opts.textBaseline) {\n ctx.textBaseline = opts.textBaseline;\n }\n}\nfunction decorateText(ctx, x, y, line, opts) {\n if (opts.strikethrough || opts.underline) {\n const metrics = ctx.measureText(line);\n const left = x - metrics.actualBoundingBoxLeft;\n const right = x + metrics.actualBoundingBoxRight;\n const top = y - metrics.actualBoundingBoxAscent;\n const bottom = y + metrics.actualBoundingBoxDescent;\n const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;\n ctx.strokeStyle = ctx.fillStyle;\n ctx.beginPath();\n ctx.lineWidth = opts.decorationWidth || 2;\n ctx.moveTo(left, yDecoration);\n ctx.lineTo(right, yDecoration);\n ctx.stroke();\n }\n}\nfunction addRoundedRectPath(ctx, rect) {\n const {x, y, w, h, radius} = rect;\n ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, -HALF_PI, PI, true);\n ctx.lineTo(x, y + h - radius.bottomLeft);\n ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);\n ctx.lineTo(x + w - radius.bottomRight, y + h);\n ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);\n ctx.lineTo(x + w, y + radius.topRight);\n ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true);\n ctx.lineTo(x + radius.topLeft, y);\n}\n\nconst LINE_HEIGHT = new RegExp(/^(normal|(\\d+(?:\\.\\d+)?)(px|em|%)?)$/);\nconst FONT_STYLE = new RegExp(/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/);\nfunction toLineHeight(value, size) {\n const matches = ('' + value).match(LINE_HEIGHT);\n if (!matches || matches[1] === 'normal') {\n return size * 1.2;\n }\n value = +matches[2];\n switch (matches[3]) {\n case 'px':\n return value;\n case '%':\n value /= 100;\n break;\n }\n return size * value;\n}\nconst numberOrZero = v => +v || 0;\nfunction _readValueToProps(value, props) {\n const ret = {};\n const objProps = isObject(props);\n const keys = objProps ? Object.keys(props) : props;\n const read = isObject(value)\n ? objProps\n ? prop => valueOrDefault(value[prop], value[props[prop]])\n : prop => value[prop]\n : () => value;\n for (const prop of keys) {\n ret[prop] = numberOrZero(read(prop));\n }\n return ret;\n}\nfunction toTRBL(value) {\n return _readValueToProps(value, {top: 'y', right: 'x', bottom: 'y', left: 'x'});\n}\nfunction toTRBLCorners(value) {\n return _readValueToProps(value, ['topLeft', 'topRight', 'bottomLeft', 'bottomRight']);\n}\nfunction toPadding(value) {\n const obj = toTRBL(value);\n obj.width = obj.left + obj.right;\n obj.height = obj.top + obj.bottom;\n return obj;\n}\nfunction toFont(options, fallback) {\n options = options || {};\n fallback = fallback || defaults.font;\n let size = valueOrDefault(options.size, fallback.size);\n if (typeof size === 'string') {\n size = parseInt(size, 10);\n }\n let style = valueOrDefault(options.style, fallback.style);\n if (style && !('' + style).match(FONT_STYLE)) {\n console.warn('Invalid font style specified: \"' + style + '\"');\n style = '';\n }\n const font = {\n family: valueOrDefault(options.family, fallback.family),\n lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),\n size,\n style,\n weight: valueOrDefault(options.weight, fallback.weight),\n string: ''\n };\n font.string = toFontString(font);\n return font;\n}\nfunction resolve(inputs, context, index, info) {\n let cacheable = true;\n let i, ilen, value;\n for (i = 0, ilen = inputs.length; i < ilen; ++i) {\n value = inputs[i];\n if (value === undefined) {\n continue;\n }\n if (context !== undefined && typeof value === 'function') {\n value = value(context);\n cacheable = false;\n }\n if (index !== undefined && isArray(value)) {\n value = value[index % value.length];\n cacheable = false;\n }\n if (value !== undefined) {\n if (info && !cacheable) {\n info.cacheable = false;\n }\n return value;\n }\n }\n}\nfunction _addGrace(minmax, grace, beginAtZero) {\n const {min, max} = minmax;\n const change = toDimension(grace, (max - min) / 2);\n const keepZero = (value, add) => beginAtZero && value === 0 ? 0 : value + add;\n return {\n min: keepZero(min, -Math.abs(change)),\n max: keepZero(max, change)\n };\n}\nfunction createContext(parentContext, context) {\n return Object.assign(Object.create(parentContext), context);\n}\n\nfunction _lookup(table, value, cmp) {\n cmp = cmp || ((index) => table[index] < value);\n let hi = table.length - 1;\n let lo = 0;\n let mid;\n while (hi - lo > 1) {\n mid = (lo + hi) >> 1;\n if (cmp(mid)) {\n lo = mid;\n } else {\n hi = mid;\n }\n }\n return {lo, hi};\n}\nconst _lookupByKey = (table, key, value) =>\n _lookup(table, value, index => table[index][key] < value);\nconst _rlookupByKey = (table, key, value) =>\n _lookup(table, value, index => table[index][key] >= value);\nfunction _filterBetween(values, min, max) {\n let start = 0;\n let end = values.length;\n while (start < end && values[start] < min) {\n start++;\n }\n while (end > start && values[end - 1] > max) {\n end--;\n }\n return start > 0 || end < values.length\n ? values.slice(start, end)\n : values;\n}\nconst arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift'];\nfunction listenArrayEvents(array, listener) {\n if (array._chartjs) {\n array._chartjs.listeners.push(listener);\n return;\n }\n Object.defineProperty(array, '_chartjs', {\n configurable: true,\n enumerable: false,\n value: {\n listeners: [listener]\n }\n });\n arrayEvents.forEach((key) => {\n const method = '_onData' + _capitalize(key);\n const base = array[key];\n Object.defineProperty(array, key, {\n configurable: true,\n enumerable: false,\n value(...args) {\n const res = base.apply(this, args);\n array._chartjs.listeners.forEach((object) => {\n if (typeof object[method] === 'function') {\n object[method](...args);\n }\n });\n return res;\n }\n });\n });\n}\nfunction unlistenArrayEvents(array, listener) {\n const stub = array._chartjs;\n if (!stub) {\n return;\n }\n const listeners = stub.listeners;\n const index = listeners.indexOf(listener);\n if (index !== -1) {\n listeners.splice(index, 1);\n }\n if (listeners.length > 0) {\n return;\n }\n arrayEvents.forEach((key) => {\n delete array[key];\n });\n delete array._chartjs;\n}\nfunction _arrayUnique(items) {\n const set = new Set();\n let i, ilen;\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n set.add(items[i]);\n }\n if (set.size === ilen) {\n return items;\n }\n return Array.from(set);\n}\n\nfunction _createResolver(scopes, prefixes = [''], rootScopes = scopes, fallback, getTarget = () => scopes[0]) {\n if (!defined(fallback)) {\n fallback = _resolve('_fallback', scopes);\n }\n const cache = {\n [Symbol.toStringTag]: 'Object',\n _cacheable: true,\n _scopes: scopes,\n _rootScopes: rootScopes,\n _fallback: fallback,\n _getTarget: getTarget,\n override: (scope) => _createResolver([scope, ...scopes], prefixes, rootScopes, fallback),\n };\n return new Proxy(cache, {\n deleteProperty(target, prop) {\n delete target[prop];\n delete target._keys;\n delete scopes[0][prop];\n return true;\n },\n get(target, prop) {\n return _cached(target, prop,\n () => _resolveWithPrefixes(prop, prefixes, scopes, target));\n },\n getOwnPropertyDescriptor(target, prop) {\n return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);\n },\n getPrototypeOf() {\n return Reflect.getPrototypeOf(scopes[0]);\n },\n has(target, prop) {\n return getKeysFromAllScopes(target).includes(prop);\n },\n ownKeys(target) {\n return getKeysFromAllScopes(target);\n },\n set(target, prop, value) {\n const storage = target._storage || (target._storage = getTarget());\n target[prop] = storage[prop] = value;\n delete target._keys;\n return true;\n }\n });\n}\nfunction _attachContext(proxy, context, subProxy, descriptorDefaults) {\n const cache = {\n _cacheable: false,\n _proxy: proxy,\n _context: context,\n _subProxy: subProxy,\n _stack: new Set(),\n _descriptors: _descriptors(proxy, descriptorDefaults),\n setContext: (ctx) => _attachContext(proxy, ctx, subProxy, descriptorDefaults),\n override: (scope) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)\n };\n return new Proxy(cache, {\n deleteProperty(target, prop) {\n delete target[prop];\n delete proxy[prop];\n return true;\n },\n get(target, prop, receiver) {\n return _cached(target, prop,\n () => _resolveWithContext(target, prop, receiver));\n },\n getOwnPropertyDescriptor(target, prop) {\n return target._descriptors.allKeys\n ? Reflect.has(proxy, prop) ? {enumerable: true, configurable: true} : undefined\n : Reflect.getOwnPropertyDescriptor(proxy, prop);\n },\n getPrototypeOf() {\n return Reflect.getPrototypeOf(proxy);\n },\n has(target, prop) {\n return Reflect.has(proxy, prop);\n },\n ownKeys() {\n return Reflect.ownKeys(proxy);\n },\n set(target, prop, value) {\n proxy[prop] = value;\n delete target[prop];\n return true;\n }\n });\n}\nfunction _descriptors(proxy, defaults = {scriptable: true, indexable: true}) {\n const {_scriptable = defaults.scriptable, _indexable = defaults.indexable, _allKeys = defaults.allKeys} = proxy;\n return {\n allKeys: _allKeys,\n scriptable: _scriptable,\n indexable: _indexable,\n isScriptable: isFunction(_scriptable) ? _scriptable : () => _scriptable,\n isIndexable: isFunction(_indexable) ? _indexable : () => _indexable\n };\n}\nconst readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name;\nconst needsSubResolver = (prop, value) => isObject(value) && prop !== 'adapters' &&\n (Object.getPrototypeOf(value) === null || value.constructor === Object);\nfunction _cached(target, prop, resolve) {\n if (Object.prototype.hasOwnProperty.call(target, prop)) {\n return target[prop];\n }\n const value = resolve();\n target[prop] = value;\n return value;\n}\nfunction _resolveWithContext(target, prop, receiver) {\n const {_proxy, _context, _subProxy, _descriptors: descriptors} = target;\n let value = _proxy[prop];\n if (isFunction(value) && descriptors.isScriptable(prop)) {\n value = _resolveScriptable(prop, value, target, receiver);\n }\n if (isArray(value) && value.length) {\n value = _resolveArray(prop, value, target, descriptors.isIndexable);\n }\n if (needsSubResolver(prop, value)) {\n value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors);\n }\n return value;\n}\nfunction _resolveScriptable(prop, value, target, receiver) {\n const {_proxy, _context, _subProxy, _stack} = target;\n if (_stack.has(prop)) {\n throw new Error('Recursion detected: ' + Array.from(_stack).join('->') + '->' + prop);\n }\n _stack.add(prop);\n value = value(_context, _subProxy || receiver);\n _stack.delete(prop);\n if (needsSubResolver(prop, value)) {\n value = createSubResolver(_proxy._scopes, _proxy, prop, value);\n }\n return value;\n}\nfunction _resolveArray(prop, value, target, isIndexable) {\n const {_proxy, _context, _subProxy, _descriptors: descriptors} = target;\n if (defined(_context.index) && isIndexable(prop)) {\n value = value[_context.index % value.length];\n } else if (isObject(value[0])) {\n const arr = value;\n const scopes = _proxy._scopes.filter(s => s !== arr);\n value = [];\n for (const item of arr) {\n const resolver = createSubResolver(scopes, _proxy, prop, item);\n value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors));\n }\n }\n return value;\n}\nfunction resolveFallback(fallback, prop, value) {\n return isFunction(fallback) ? fallback(prop, value) : fallback;\n}\nconst getScope = (key, parent) => key === true ? parent\n : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined;\nfunction addScopes(set, parentScopes, key, parentFallback, value) {\n for (const parent of parentScopes) {\n const scope = getScope(key, parent);\n if (scope) {\n set.add(scope);\n const fallback = resolveFallback(scope._fallback, key, value);\n if (defined(fallback) && fallback !== key && fallback !== parentFallback) {\n return fallback;\n }\n } else if (scope === false && defined(parentFallback) && key !== parentFallback) {\n return null;\n }\n }\n return false;\n}\nfunction createSubResolver(parentScopes, resolver, prop, value) {\n const rootScopes = resolver._rootScopes;\n const fallback = resolveFallback(resolver._fallback, prop, value);\n const allScopes = [...parentScopes, ...rootScopes];\n const set = new Set();\n set.add(value);\n let key = addScopesFromKey(set, allScopes, prop, fallback || prop, value);\n if (key === null) {\n return false;\n }\n if (defined(fallback) && fallback !== prop) {\n key = addScopesFromKey(set, allScopes, fallback, key, value);\n if (key === null) {\n return false;\n }\n }\n return _createResolver(Array.from(set), [''], rootScopes, fallback,\n () => subGetTarget(resolver, prop, value));\n}\nfunction addScopesFromKey(set, allScopes, key, fallback, item) {\n while (key) {\n key = addScopes(set, allScopes, key, fallback, item);\n }\n return key;\n}\nfunction subGetTarget(resolver, prop, value) {\n const parent = resolver._getTarget();\n if (!(prop in parent)) {\n parent[prop] = {};\n }\n const target = parent[prop];\n if (isArray(target) && isObject(value)) {\n return value;\n }\n return target;\n}\nfunction _resolveWithPrefixes(prop, prefixes, scopes, proxy) {\n let value;\n for (const prefix of prefixes) {\n value = _resolve(readKey(prefix, prop), scopes);\n if (defined(value)) {\n return needsSubResolver(prop, value)\n ? createSubResolver(scopes, proxy, prop, value)\n : value;\n }\n }\n}\nfunction _resolve(key, scopes) {\n for (const scope of scopes) {\n if (!scope) {\n continue;\n }\n const value = scope[key];\n if (defined(value)) {\n return value;\n }\n }\n}\nfunction getKeysFromAllScopes(target) {\n let keys = target._keys;\n if (!keys) {\n keys = target._keys = resolveKeysFromAllScopes(target._scopes);\n }\n return keys;\n}\nfunction resolveKeysFromAllScopes(scopes) {\n const set = new Set();\n for (const scope of scopes) {\n for (const key of Object.keys(scope).filter(k => !k.startsWith('_'))) {\n set.add(key);\n }\n }\n return Array.from(set);\n}\nfunction _parseObjectDataRadialScale(meta, data, start, count) {\n const {iScale} = meta;\n const {key = 'r'} = this._parsing;\n const parsed = new Array(count);\n let i, ilen, index, item;\n for (i = 0, ilen = count; i < ilen; ++i) {\n index = i + start;\n item = data[index];\n parsed[i] = {\n r: iScale.parse(resolveObjectKey(item, key), index)\n };\n }\n return parsed;\n}\n\nconst EPSILON = Number.EPSILON || 1e-14;\nconst getPoint = (points, i) => i < points.length && !points[i].skip && points[i];\nconst getValueAxis = (indexAxis) => indexAxis === 'x' ? 'y' : 'x';\nfunction splineCurve(firstPoint, middlePoint, afterPoint, t) {\n const previous = firstPoint.skip ? middlePoint : firstPoint;\n const current = middlePoint;\n const next = afterPoint.skip ? middlePoint : afterPoint;\n const d01 = distanceBetweenPoints(current, previous);\n const d12 = distanceBetweenPoints(next, current);\n let s01 = d01 / (d01 + d12);\n let s12 = d12 / (d01 + d12);\n s01 = isNaN(s01) ? 0 : s01;\n s12 = isNaN(s12) ? 0 : s12;\n const fa = t * s01;\n const fb = t * s12;\n return {\n previous: {\n x: current.x - fa * (next.x - previous.x),\n y: current.y - fa * (next.y - previous.y)\n },\n next: {\n x: current.x + fb * (next.x - previous.x),\n y: current.y + fb * (next.y - previous.y)\n }\n };\n}\nfunction monotoneAdjust(points, deltaK, mK) {\n const pointsLen = points.length;\n let alphaK, betaK, tauK, squaredMagnitude, pointCurrent;\n let pointAfter = getPoint(points, 0);\n for (let i = 0; i < pointsLen - 1; ++i) {\n pointCurrent = pointAfter;\n pointAfter = getPoint(points, i + 1);\n if (!pointCurrent || !pointAfter) {\n continue;\n }\n if (almostEquals(deltaK[i], 0, EPSILON)) {\n mK[i] = mK[i + 1] = 0;\n continue;\n }\n alphaK = mK[i] / deltaK[i];\n betaK = mK[i + 1] / deltaK[i];\n squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);\n if (squaredMagnitude <= 9) {\n continue;\n }\n tauK = 3 / Math.sqrt(squaredMagnitude);\n mK[i] = alphaK * tauK * deltaK[i];\n mK[i + 1] = betaK * tauK * deltaK[i];\n }\n}\nfunction monotoneCompute(points, mK, indexAxis = 'x') {\n const valueAxis = getValueAxis(indexAxis);\n const pointsLen = points.length;\n let delta, pointBefore, pointCurrent;\n let pointAfter = getPoint(points, 0);\n for (let i = 0; i < pointsLen; ++i) {\n pointBefore = pointCurrent;\n pointCurrent = pointAfter;\n pointAfter = getPoint(points, i + 1);\n if (!pointCurrent) {\n continue;\n }\n const iPixel = pointCurrent[indexAxis];\n const vPixel = pointCurrent[valueAxis];\n if (pointBefore) {\n delta = (iPixel - pointBefore[indexAxis]) / 3;\n pointCurrent[`cp1${indexAxis}`] = iPixel - delta;\n pointCurrent[`cp1${valueAxis}`] = vPixel - delta * mK[i];\n }\n if (pointAfter) {\n delta = (pointAfter[indexAxis] - iPixel) / 3;\n pointCurrent[`cp2${indexAxis}`] = iPixel + delta;\n pointCurrent[`cp2${valueAxis}`] = vPixel + delta * mK[i];\n }\n }\n}\nfunction splineCurveMonotone(points, indexAxis = 'x') {\n const valueAxis = getValueAxis(indexAxis);\n const pointsLen = points.length;\n const deltaK = Array(pointsLen).fill(0);\n const mK = Array(pointsLen);\n let i, pointBefore, pointCurrent;\n let pointAfter = getPoint(points, 0);\n for (i = 0; i < pointsLen; ++i) {\n pointBefore = pointCurrent;\n pointCurrent = pointAfter;\n pointAfter = getPoint(points, i + 1);\n if (!pointCurrent) {\n continue;\n }\n if (pointAfter) {\n const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis];\n deltaK[i] = slopeDelta !== 0 ? (pointAfter[valueAxis] - pointCurrent[valueAxis]) / slopeDelta : 0;\n }\n mK[i] = !pointBefore ? deltaK[i]\n : !pointAfter ? deltaK[i - 1]\n : (sign(deltaK[i - 1]) !== sign(deltaK[i])) ? 0\n : (deltaK[i - 1] + deltaK[i]) / 2;\n }\n monotoneAdjust(points, deltaK, mK);\n monotoneCompute(points, mK, indexAxis);\n}\nfunction capControlPoint(pt, min, max) {\n return Math.max(Math.min(pt, max), min);\n}\nfunction capBezierPoints(points, area) {\n let i, ilen, point, inArea, inAreaPrev;\n let inAreaNext = _isPointInArea(points[0], area);\n for (i = 0, ilen = points.length; i < ilen; ++i) {\n inAreaPrev = inArea;\n inArea = inAreaNext;\n inAreaNext = i < ilen - 1 && _isPointInArea(points[i + 1], area);\n if (!inArea) {\n continue;\n }\n point = points[i];\n if (inAreaPrev) {\n point.cp1x = capControlPoint(point.cp1x, area.left, area.right);\n point.cp1y = capControlPoint(point.cp1y, area.top, area.bottom);\n }\n if (inAreaNext) {\n point.cp2x = capControlPoint(point.cp2x, area.left, area.right);\n point.cp2y = capControlPoint(point.cp2y, area.top, area.bottom);\n }\n }\n}\nfunction _updateBezierControlPoints(points, options, area, loop, indexAxis) {\n let i, ilen, point, controlPoints;\n if (options.spanGaps) {\n points = points.filter((pt) => !pt.skip);\n }\n if (options.cubicInterpolationMode === 'monotone') {\n splineCurveMonotone(points, indexAxis);\n } else {\n let prev = loop ? points[points.length - 1] : points[0];\n for (i = 0, ilen = points.length; i < ilen; ++i) {\n point = points[i];\n controlPoints = splineCurve(\n prev,\n point,\n points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen],\n options.tension\n );\n point.cp1x = controlPoints.previous.x;\n point.cp1y = controlPoints.previous.y;\n point.cp2x = controlPoints.next.x;\n point.cp2y = controlPoints.next.y;\n prev = point;\n }\n }\n if (options.capBezierPoints) {\n capBezierPoints(points, area);\n }\n}\n\nfunction _isDomSupported() {\n return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\nfunction _getParentNode(domNode) {\n let parent = domNode.parentNode;\n if (parent && parent.toString() === '[object ShadowRoot]') {\n parent = parent.host;\n }\n return parent;\n}\nfunction parseMaxStyle(styleValue, node, parentProperty) {\n let valueInPixels;\n if (typeof styleValue === 'string') {\n valueInPixels = parseInt(styleValue, 10);\n if (styleValue.indexOf('%') !== -1) {\n valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];\n }\n } else {\n valueInPixels = styleValue;\n }\n return valueInPixels;\n}\nconst getComputedStyle = (element) => window.getComputedStyle(element, null);\nfunction getStyle(el, property) {\n return getComputedStyle(el).getPropertyValue(property);\n}\nconst positions = ['top', 'right', 'bottom', 'left'];\nfunction getPositionedStyle(styles, style, suffix) {\n const result = {};\n suffix = suffix ? '-' + suffix : '';\n for (let i = 0; i < 4; i++) {\n const pos = positions[i];\n result[pos] = parseFloat(styles[style + '-' + pos + suffix]) || 0;\n }\n result.width = result.left + result.right;\n result.height = result.top + result.bottom;\n return result;\n}\nconst useOffsetPos = (x, y, target) => (x > 0 || y > 0) && (!target || !target.shadowRoot);\nfunction getCanvasPosition(e, canvas) {\n const touches = e.touches;\n const source = touches && touches.length ? touches[0] : e;\n const {offsetX, offsetY} = source;\n let box = false;\n let x, y;\n if (useOffsetPos(offsetX, offsetY, e.target)) {\n x = offsetX;\n y = offsetY;\n } else {\n const rect = canvas.getBoundingClientRect();\n x = source.clientX - rect.left;\n y = source.clientY - rect.top;\n box = true;\n }\n return {x, y, box};\n}\nfunction getRelativePosition(evt, chart) {\n if ('native' in evt) {\n return evt;\n }\n const {canvas, currentDevicePixelRatio} = chart;\n const style = getComputedStyle(canvas);\n const borderBox = style.boxSizing === 'border-box';\n const paddings = getPositionedStyle(style, 'padding');\n const borders = getPositionedStyle(style, 'border', 'width');\n const {x, y, box} = getCanvasPosition(evt, canvas);\n const xOffset = paddings.left + (box && borders.left);\n const yOffset = paddings.top + (box && borders.top);\n let {width, height} = chart;\n if (borderBox) {\n width -= paddings.width + borders.width;\n height -= paddings.height + borders.height;\n }\n return {\n x: Math.round((x - xOffset) / width * canvas.width / currentDevicePixelRatio),\n y: Math.round((y - yOffset) / height * canvas.height / currentDevicePixelRatio)\n };\n}\nfunction getContainerSize(canvas, width, height) {\n let maxWidth, maxHeight;\n if (width === undefined || height === undefined) {\n const container = _getParentNode(canvas);\n if (!container) {\n width = canvas.clientWidth;\n height = canvas.clientHeight;\n } else {\n const rect = container.getBoundingClientRect();\n const containerStyle = getComputedStyle(container);\n const containerBorder = getPositionedStyle(containerStyle, 'border', 'width');\n const containerPadding = getPositionedStyle(containerStyle, 'padding');\n width = rect.width - containerPadding.width - containerBorder.width;\n height = rect.height - containerPadding.height - containerBorder.height;\n maxWidth = parseMaxStyle(containerStyle.maxWidth, container, 'clientWidth');\n maxHeight = parseMaxStyle(containerStyle.maxHeight, container, 'clientHeight');\n }\n }\n return {\n width,\n height,\n maxWidth: maxWidth || INFINITY,\n maxHeight: maxHeight || INFINITY\n };\n}\nconst round1 = v => Math.round(v * 10) / 10;\nfunction getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) {\n const style = getComputedStyle(canvas);\n const margins = getPositionedStyle(style, 'margin');\n const maxWidth = parseMaxStyle(style.maxWidth, canvas, 'clientWidth') || INFINITY;\n const maxHeight = parseMaxStyle(style.maxHeight, canvas, 'clientHeight') || INFINITY;\n const containerSize = getContainerSize(canvas, bbWidth, bbHeight);\n let {width, height} = containerSize;\n if (style.boxSizing === 'content-box') {\n const borders = getPositionedStyle(style, 'border', 'width');\n const paddings = getPositionedStyle(style, 'padding');\n width -= paddings.width + borders.width;\n height -= paddings.height + borders.height;\n }\n width = Math.max(0, width - margins.width);\n height = Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height - margins.height);\n width = round1(Math.min(width, maxWidth, containerSize.maxWidth));\n height = round1(Math.min(height, maxHeight, containerSize.maxHeight));\n if (width && !height) {\n height = round1(width / 2);\n }\n return {\n width,\n height\n };\n}\nfunction retinaScale(chart, forceRatio, forceStyle) {\n const pixelRatio = forceRatio || 1;\n const deviceHeight = Math.floor(chart.height * pixelRatio);\n const deviceWidth = Math.floor(chart.width * pixelRatio);\n chart.height = deviceHeight / pixelRatio;\n chart.width = deviceWidth / pixelRatio;\n const canvas = chart.canvas;\n if (canvas.style && (forceStyle || (!canvas.style.height && !canvas.style.width))) {\n canvas.style.height = `${chart.height}px`;\n canvas.style.width = `${chart.width}px`;\n }\n if (chart.currentDevicePixelRatio !== pixelRatio\n || canvas.height !== deviceHeight\n || canvas.width !== deviceWidth) {\n chart.currentDevicePixelRatio = pixelRatio;\n canvas.height = deviceHeight;\n canvas.width = deviceWidth;\n chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);\n return true;\n }\n return false;\n}\nconst supportsEventListenerOptions = (function() {\n let passiveSupported = false;\n try {\n const options = {\n get passive() {\n passiveSupported = true;\n return false;\n }\n };\n window.addEventListener('test', null, options);\n window.removeEventListener('test', null, options);\n } catch (e) {\n }\n return passiveSupported;\n}());\nfunction readUsedSize(element, property) {\n const value = getStyle(element, property);\n const matches = value && value.match(/^(\\d+)(\\.\\d+)?px$/);\n return matches ? +matches[1] : undefined;\n}\n\nfunction _pointInLine(p1, p2, t, mode) {\n return {\n x: p1.x + t * (p2.x - p1.x),\n y: p1.y + t * (p2.y - p1.y)\n };\n}\nfunction _steppedInterpolation(p1, p2, t, mode) {\n return {\n x: p1.x + t * (p2.x - p1.x),\n y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y\n : mode === 'after' ? t < 1 ? p1.y : p2.y\n : t > 0 ? p2.y : p1.y\n };\n}\nfunction _bezierInterpolation(p1, p2, t, mode) {\n const cp1 = {x: p1.cp2x, y: p1.cp2y};\n const cp2 = {x: p2.cp1x, y: p2.cp1y};\n const a = _pointInLine(p1, cp1, t);\n const b = _pointInLine(cp1, cp2, t);\n const c = _pointInLine(cp2, p2, t);\n const d = _pointInLine(a, b, t);\n const e = _pointInLine(b, c, t);\n return _pointInLine(d, e, t);\n}\n\nconst intlCache = new Map();\nfunction getNumberFormat(locale, options) {\n options = options || {};\n const cacheKey = locale + JSON.stringify(options);\n let formatter = intlCache.get(cacheKey);\n if (!formatter) {\n formatter = new Intl.NumberFormat(locale, options);\n intlCache.set(cacheKey, formatter);\n }\n return formatter;\n}\nfunction formatNumber(num, locale, options) {\n return getNumberFormat(locale, options).format(num);\n}\n\nconst getRightToLeftAdapter = function(rectX, width) {\n return {\n x(x) {\n return rectX + rectX + width - x;\n },\n setWidth(w) {\n width = w;\n },\n textAlign(align) {\n if (align === 'center') {\n return align;\n }\n return align === 'right' ? 'left' : 'right';\n },\n xPlus(x, value) {\n return x - value;\n },\n leftForLtr(x, itemWidth) {\n return x - itemWidth;\n },\n };\n};\nconst getLeftToRightAdapter = function() {\n return {\n x(x) {\n return x;\n },\n setWidth(w) {\n },\n textAlign(align) {\n return align;\n },\n xPlus(x, value) {\n return x + value;\n },\n leftForLtr(x, _itemWidth) {\n return x;\n },\n };\n};\nfunction getRtlAdapter(rtl, rectX, width) {\n return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();\n}\nfunction overrideTextDirection(ctx, direction) {\n let style, original;\n if (direction === 'ltr' || direction === 'rtl') {\n style = ctx.canvas.style;\n original = [\n style.getPropertyValue('direction'),\n style.getPropertyPriority('direction'),\n ];\n style.setProperty('direction', direction, 'important');\n ctx.prevTextDirection = original;\n }\n}\nfunction restoreTextDirection(ctx, original) {\n if (original !== undefined) {\n delete ctx.prevTextDirection;\n ctx.canvas.style.setProperty('direction', original[0], original[1]);\n }\n}\n\nfunction propertyFn(property) {\n if (property === 'angle') {\n return {\n between: _angleBetween,\n compare: _angleDiff,\n normalize: _normalizeAngle,\n };\n }\n return {\n between: _isBetween,\n compare: (a, b) => a - b,\n normalize: x => x\n };\n}\nfunction normalizeSegment({start, end, count, loop, style}) {\n return {\n start: start % count,\n end: end % count,\n loop: loop && (end - start + 1) % count === 0,\n style\n };\n}\nfunction getSegment(segment, points, bounds) {\n const {property, start: startBound, end: endBound} = bounds;\n const {between, normalize} = propertyFn(property);\n const count = points.length;\n let {start, end, loop} = segment;\n let i, ilen;\n if (loop) {\n start += count;\n end += count;\n for (i = 0, ilen = count; i < ilen; ++i) {\n if (!between(normalize(points[start % count][property]), startBound, endBound)) {\n break;\n }\n start--;\n end--;\n }\n start %= count;\n end %= count;\n }\n if (end < start) {\n end += count;\n }\n return {start, end, loop, style: segment.style};\n}\nfunction _boundSegment(segment, points, bounds) {\n if (!bounds) {\n return [segment];\n }\n const {property, start: startBound, end: endBound} = bounds;\n const count = points.length;\n const {compare, between, normalize} = propertyFn(property);\n const {start, end, loop, style} = getSegment(segment, points, bounds);\n const result = [];\n let inside = false;\n let subStart = null;\n let value, point, prevValue;\n const startIsBefore = () => between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0;\n const endIsBefore = () => compare(endBound, value) === 0 || between(endBound, prevValue, value);\n const shouldStart = () => inside || startIsBefore();\n const shouldStop = () => !inside || endIsBefore();\n for (let i = start, prev = start; i <= end; ++i) {\n point = points[i % count];\n if (point.skip) {\n continue;\n }\n value = normalize(point[property]);\n if (value === prevValue) {\n continue;\n }\n inside = between(value, startBound, endBound);\n if (subStart === null && shouldStart()) {\n subStart = compare(value, startBound) === 0 ? i : prev;\n }\n if (subStart !== null && shouldStop()) {\n result.push(normalizeSegment({start: subStart, end: i, loop, count, style}));\n subStart = null;\n }\n prev = i;\n prevValue = value;\n }\n if (subStart !== null) {\n result.push(normalizeSegment({start: subStart, end, loop, count, style}));\n }\n return result;\n}\nfunction _boundSegments(line, bounds) {\n const result = [];\n const segments = line.segments;\n for (let i = 0; i < segments.length; i++) {\n const sub = _boundSegment(segments[i], line.points, bounds);\n if (sub.length) {\n result.push(...sub);\n }\n }\n return result;\n}\nfunction findStartAndEnd(points, count, loop, spanGaps) {\n let start = 0;\n let end = count - 1;\n if (loop && !spanGaps) {\n while (start < count && !points[start].skip) {\n start++;\n }\n }\n while (start < count && points[start].skip) {\n start++;\n }\n start %= count;\n if (loop) {\n end += start;\n }\n while (end > start && points[end % count].skip) {\n end--;\n }\n end %= count;\n return {start, end};\n}\nfunction solidSegments(points, start, max, loop) {\n const count = points.length;\n const result = [];\n let last = start;\n let prev = points[start];\n let end;\n for (end = start + 1; end <= max; ++end) {\n const cur = points[end % count];\n if (cur.skip || cur.stop) {\n if (!prev.skip) {\n loop = false;\n result.push({start: start % count, end: (end - 1) % count, loop});\n start = last = cur.stop ? end : null;\n }\n } else {\n last = end;\n if (prev.skip) {\n start = end;\n }\n }\n prev = cur;\n }\n if (last !== null) {\n result.push({start: start % count, end: last % count, loop});\n }\n return result;\n}\nfunction _computeSegments(line, segmentOptions) {\n const points = line.points;\n const spanGaps = line.options.spanGaps;\n const count = points.length;\n if (!count) {\n return [];\n }\n const loop = !!line._loop;\n const {start, end} = findStartAndEnd(points, count, loop, spanGaps);\n if (spanGaps === true) {\n return splitByStyles(line, [{start, end, loop}], points, segmentOptions);\n }\n const max = end < start ? end + count : end;\n const completeLoop = !!line._fullLoop && start === 0 && end === count - 1;\n return splitByStyles(line, solidSegments(points, start, max, completeLoop), points, segmentOptions);\n}\nfunction splitByStyles(line, segments, points, segmentOptions) {\n if (!segmentOptions || !segmentOptions.setContext || !points) {\n return segments;\n }\n return doSplitByStyles(line, segments, points, segmentOptions);\n}\nfunction doSplitByStyles(line, segments, points, segmentOptions) {\n const chartContext = line._chart.getContext();\n const baseStyle = readStyle(line.options);\n const {_datasetIndex: datasetIndex, options: {spanGaps}} = line;\n const count = points.length;\n const result = [];\n let prevStyle = baseStyle;\n let start = segments[0].start;\n let i = start;\n function addStyle(s, e, l, st) {\n const dir = spanGaps ? -1 : 1;\n if (s === e) {\n return;\n }\n s += count;\n while (points[s % count].skip) {\n s -= dir;\n }\n while (points[e % count].skip) {\n e += dir;\n }\n if (s % count !== e % count) {\n result.push({start: s % count, end: e % count, loop: l, style: st});\n prevStyle = st;\n start = e % count;\n }\n }\n for (const segment of segments) {\n start = spanGaps ? start : segment.start;\n let prev = points[start % count];\n let style;\n for (i = start + 1; i <= segment.end; i++) {\n const pt = points[i % count];\n style = readStyle(segmentOptions.setContext(createContext(chartContext, {\n type: 'segment',\n p0: prev,\n p1: pt,\n p0DataIndex: (i - 1) % count,\n p1DataIndex: i % count,\n datasetIndex\n })));\n if (styleChanged(style, prevStyle)) {\n addStyle(start, i - 1, segment.loop, prevStyle);\n }\n prev = pt;\n prevStyle = style;\n }\n if (start < i - 1) {\n addStyle(start, i - 1, segment.loop, prevStyle);\n }\n }\n return result;\n}\nfunction readStyle(options) {\n return {\n backgroundColor: options.backgroundColor,\n borderCapStyle: options.borderCapStyle,\n borderDash: options.borderDash,\n borderDashOffset: options.borderDashOffset,\n borderJoinStyle: options.borderJoinStyle,\n borderWidth: options.borderWidth,\n borderColor: options.borderColor\n };\n}\nfunction styleChanged(style, prevStyle) {\n return prevStyle && JSON.stringify(style) !== JSON.stringify(prevStyle);\n}\n\nexport { toFont as $, _rlookupByKey as A, _isPointInArea as B, getAngleFromPoint as C, toPadding as D, each as E, getMaximumSize as F, _getParentNode as G, HALF_PI as H, readUsedSize as I, throttled as J, supportsEventListenerOptions as K, _isDomSupported as L, log10 as M, _factorize as N, finiteOrDefault as O, PI as P, callback as Q, _addGrace as R, toDegrees as S, TAU as T, _measureText as U, _int16Range as V, _alignPixel as W, clipArea as X, renderText as Y, unclipArea as Z, _arrayUnique as _, resolve as a, QUARTER_PI as a$, _toLeftRightCenter as a0, _alignStartEnd as a1, overrides as a2, merge as a3, _capitalize as a4, descriptors as a5, isFunction as a6, _attachContext as a7, _createResolver as a8, _descriptors as a9, _textX as aA, restoreTextDirection as aB, noop as aC, distanceBetweenPoints as aD, _setMinAndMaxByKey as aE, niceNum as aF, almostWhole as aG, almostEquals as aH, _decimalPlaces as aI, _longestText as aJ, _filterBetween as aK, _lookup as aL, isPatternOrGradient as aM, getHoverColor as aN, clone$1 as aO, _merger as aP, _mergerIf as aQ, _deprecated as aR, toFontString as aS, splineCurve as aT, splineCurveMonotone as aU, getStyle as aV, fontString as aW, toLineHeight as aX, PITAU as aY, INFINITY as aZ, RAD_PER_DEG as a_, mergeIf as aa, uid as ab, debounce as ac, retinaScale as ad, clearCanvas as ae, setsEqual as af, _elementsEqual as ag, _isClickEvent as ah, _isBetween as ai, _readValueToProps as aj, _updateBezierControlPoints as ak, _computeSegments as al, _boundSegments as am, _steppedInterpolation as an, _bezierInterpolation as ao, _pointInLine as ap, _steppedLineTo as aq, _bezierCurveTo as ar, drawPoint as as, addRoundedRectPath as at, toTRBL as au, toTRBLCorners as av, _boundSegment as aw, _normalizeAngle as ax, getRtlAdapter as ay, overrideTextDirection as az, isArray as b, TWO_THIRDS_PI as b0, _angleDiff as b1, color as c, defaults as d, effects as e, resolveObjectKey as f, isNumberFinite as g, createContext as h, isObject as i, defined as j, isNullOrUndef as k, listenArrayEvents as l, toPercentage as m, toDimension as n, formatNumber as o, _angleBetween as p, isNumber as q, requestAnimFrame as r, sign as s, toRadians as t, unlistenArrayEvents as u, valueOrDefault as v, _limitValue as w, _lookupByKey as x, _parseObjectDataRadialScale as y, getRelativePosition as z };\n","/*!\n * Chart.js v3.8.0\n * https://www.chartjs.org\n * (c) 2022 Chart.js Contributors\n * Released under the MIT License\n */\nimport { r as requestAnimFrame, a as resolve, e as effects, c as color, d as defaults, i as isObject, b as isArray, v as valueOrDefault, u as unlistenArrayEvents, l as listenArrayEvents, f as resolveObjectKey, g as isNumberFinite, h as createContext, j as defined, s as sign, k as isNullOrUndef, _ as _arrayUnique, t as toRadians, m as toPercentage, n as toDimension, T as TAU, o as formatNumber, p as _angleBetween, H as HALF_PI, P as PI, q as isNumber, w as _limitValue, x as _lookupByKey, y as _parseObjectDataRadialScale, z as getRelativePosition, A as _rlookupByKey, B as _isPointInArea, C as getAngleFromPoint, D as toPadding, E as each, F as getMaximumSize, G as _getParentNode, I as readUsedSize, J as throttled, K as supportsEventListenerOptions, L as _isDomSupported, M as log10, N as _factorize, O as finiteOrDefault, Q as callback, R as _addGrace, S as toDegrees, U as _measureText, V as _int16Range, W as _alignPixel, X as clipArea, Y as renderText, Z as unclipArea, $ as toFont, a0 as _toLeftRightCenter, a1 as _alignStartEnd, a2 as overrides, a3 as merge, a4 as _capitalize, a5 as descriptors, a6 as isFunction, a7 as _attachContext, a8 as _createResolver, a9 as _descriptors, aa as mergeIf, ab as uid, ac as debounce, ad as retinaScale, ae as clearCanvas, af as setsEqual, ag as _elementsEqual, ah as _isClickEvent, ai as _isBetween, aj as _readValueToProps, ak as _updateBezierControlPoints, al as _computeSegments, am as _boundSegments, an as _steppedInterpolation, ao as _bezierInterpolation, ap as _pointInLine, aq as _steppedLineTo, ar as _bezierCurveTo, as as drawPoint, at as addRoundedRectPath, au as toTRBL, av as toTRBLCorners, aw as _boundSegment, ax as _normalizeAngle, ay as getRtlAdapter, az as overrideTextDirection, aA as _textX, aB as restoreTextDirection, aC as noop, aD as distanceBetweenPoints, aE as _setMinAndMaxByKey, aF as niceNum, aG as almostWhole, aH as almostEquals, aI as _decimalPlaces, aJ as _longestText, aK as _filterBetween, aL as _lookup } from './chunks/helpers.segment.js';\nexport { d as defaults } from './chunks/helpers.segment.js';\n\nclass Animator {\n constructor() {\n this._request = null;\n this._charts = new Map();\n this._running = false;\n this._lastDate = undefined;\n }\n _notify(chart, anims, date, type) {\n const callbacks = anims.listeners[type];\n const numSteps = anims.duration;\n callbacks.forEach(fn => fn({\n chart,\n initial: anims.initial,\n numSteps,\n currentStep: Math.min(date - anims.start, numSteps)\n }));\n }\n _refresh() {\n if (this._request) {\n return;\n }\n this._running = true;\n this._request = requestAnimFrame.call(window, () => {\n this._update();\n this._request = null;\n if (this._running) {\n this._refresh();\n }\n });\n }\n _update(date = Date.now()) {\n let remaining = 0;\n this._charts.forEach((anims, chart) => {\n if (!anims.running || !anims.items.length) {\n return;\n }\n const items = anims.items;\n let i = items.length - 1;\n let draw = false;\n let item;\n for (; i >= 0; --i) {\n item = items[i];\n if (item._active) {\n if (item._total > anims.duration) {\n anims.duration = item._total;\n }\n item.tick(date);\n draw = true;\n } else {\n items[i] = items[items.length - 1];\n items.pop();\n }\n }\n if (draw) {\n chart.draw();\n this._notify(chart, anims, date, 'progress');\n }\n if (!items.length) {\n anims.running = false;\n this._notify(chart, anims, date, 'complete');\n anims.initial = false;\n }\n remaining += items.length;\n });\n this._lastDate = date;\n if (remaining === 0) {\n this._running = false;\n }\n }\n _getAnims(chart) {\n const charts = this._charts;\n let anims = charts.get(chart);\n if (!anims) {\n anims = {\n running: false,\n initial: true,\n items: [],\n listeners: {\n complete: [],\n progress: []\n }\n };\n charts.set(chart, anims);\n }\n return anims;\n }\n listen(chart, event, cb) {\n this._getAnims(chart).listeners[event].push(cb);\n }\n add(chart, items) {\n if (!items || !items.length) {\n return;\n }\n this._getAnims(chart).items.push(...items);\n }\n has(chart) {\n return this._getAnims(chart).items.length > 0;\n }\n start(chart) {\n const anims = this._charts.get(chart);\n if (!anims) {\n return;\n }\n anims.running = true;\n anims.start = Date.now();\n anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0);\n this._refresh();\n }\n running(chart) {\n if (!this._running) {\n return false;\n }\n const anims = this._charts.get(chart);\n if (!anims || !anims.running || !anims.items.length) {\n return false;\n }\n return true;\n }\n stop(chart) {\n const anims = this._charts.get(chart);\n if (!anims || !anims.items.length) {\n return;\n }\n const items = anims.items;\n let i = items.length - 1;\n for (; i >= 0; --i) {\n items[i].cancel();\n }\n anims.items = [];\n this._notify(chart, anims, Date.now(), 'complete');\n }\n remove(chart) {\n return this._charts.delete(chart);\n }\n}\nvar animator = new Animator();\n\nconst transparent = 'transparent';\nconst interpolators = {\n boolean(from, to, factor) {\n return factor > 0.5 ? to : from;\n },\n color(from, to, factor) {\n const c0 = color(from || transparent);\n const c1 = c0.valid && color(to || transparent);\n return c1 && c1.valid\n ? c1.mix(c0, factor).hexString()\n : to;\n },\n number(from, to, factor) {\n return from + (to - from) * factor;\n }\n};\nclass Animation {\n constructor(cfg, target, prop, to) {\n const currentValue = target[prop];\n to = resolve([cfg.to, to, currentValue, cfg.from]);\n const from = resolve([cfg.from, currentValue, to]);\n this._active = true;\n this._fn = cfg.fn || interpolators[cfg.type || typeof from];\n this._easing = effects[cfg.easing] || effects.linear;\n this._start = Math.floor(Date.now() + (cfg.delay || 0));\n this._duration = this._total = Math.floor(cfg.duration);\n this._loop = !!cfg.loop;\n this._target = target;\n this._prop = prop;\n this._from = from;\n this._to = to;\n this._promises = undefined;\n }\n active() {\n return this._active;\n }\n update(cfg, to, date) {\n if (this._active) {\n this._notify(false);\n const currentValue = this._target[this._prop];\n const elapsed = date - this._start;\n const remain = this._duration - elapsed;\n this._start = date;\n this._duration = Math.floor(Math.max(remain, cfg.duration));\n this._total += elapsed;\n this._loop = !!cfg.loop;\n this._to = resolve([cfg.to, to, currentValue, cfg.from]);\n this._from = resolve([cfg.from, currentValue, to]);\n }\n }\n cancel() {\n if (this._active) {\n this.tick(Date.now());\n this._active = false;\n this._notify(false);\n }\n }\n tick(date) {\n const elapsed = date - this._start;\n const duration = this._duration;\n const prop = this._prop;\n const from = this._from;\n const loop = this._loop;\n const to = this._to;\n let factor;\n this._active = from !== to && (loop || (elapsed < duration));\n if (!this._active) {\n this._target[prop] = to;\n this._notify(true);\n return;\n }\n if (elapsed < 0) {\n this._target[prop] = from;\n return;\n }\n factor = (elapsed / duration) % 2;\n factor = loop && factor > 1 ? 2 - factor : factor;\n factor = this._easing(Math.min(1, Math.max(0, factor)));\n this._target[prop] = this._fn(from, to, factor);\n }\n wait() {\n const promises = this._promises || (this._promises = []);\n return new Promise((res, rej) => {\n promises.push({res, rej});\n });\n }\n _notify(resolved) {\n const method = resolved ? 'res' : 'rej';\n const promises = this._promises || [];\n for (let i = 0; i < promises.length; i++) {\n promises[i][method]();\n }\n }\n}\n\nconst numbers = ['x', 'y', 'borderWidth', 'radius', 'tension'];\nconst colors = ['color', 'borderColor', 'backgroundColor'];\ndefaults.set('animation', {\n delay: undefined,\n duration: 1000,\n easing: 'easeOutQuart',\n fn: undefined,\n from: undefined,\n loop: undefined,\n to: undefined,\n type: undefined,\n});\nconst animationOptions = Object.keys(defaults.animation);\ndefaults.describe('animation', {\n _fallback: false,\n _indexable: false,\n _scriptable: (name) => name !== 'onProgress' && name !== 'onComplete' && name !== 'fn',\n});\ndefaults.set('animations', {\n colors: {\n type: 'color',\n properties: colors\n },\n numbers: {\n type: 'number',\n properties: numbers\n },\n});\ndefaults.describe('animations', {\n _fallback: 'animation',\n});\ndefaults.set('transitions', {\n active: {\n animation: {\n duration: 400\n }\n },\n resize: {\n animation: {\n duration: 0\n }\n },\n show: {\n animations: {\n colors: {\n from: 'transparent'\n },\n visible: {\n type: 'boolean',\n duration: 0\n },\n }\n },\n hide: {\n animations: {\n colors: {\n to: 'transparent'\n },\n visible: {\n type: 'boolean',\n easing: 'linear',\n fn: v => v | 0\n },\n }\n }\n});\nclass Animations {\n constructor(chart, config) {\n this._chart = chart;\n this._properties = new Map();\n this.configure(config);\n }\n configure(config) {\n if (!isObject(config)) {\n return;\n }\n const animatedProps = this._properties;\n Object.getOwnPropertyNames(config).forEach(key => {\n const cfg = config[key];\n if (!isObject(cfg)) {\n return;\n }\n const resolved = {};\n for (const option of animationOptions) {\n resolved[option] = cfg[option];\n }\n (isArray(cfg.properties) && cfg.properties || [key]).forEach((prop) => {\n if (prop === key || !animatedProps.has(prop)) {\n animatedProps.set(prop, resolved);\n }\n });\n });\n }\n _animateOptions(target, values) {\n const newOptions = values.options;\n const options = resolveTargetOptions(target, newOptions);\n if (!options) {\n return [];\n }\n const animations = this._createAnimations(options, newOptions);\n if (newOptions.$shared) {\n awaitAll(target.options.$animations, newOptions).then(() => {\n target.options = newOptions;\n }, () => {\n });\n }\n return animations;\n }\n _createAnimations(target, values) {\n const animatedProps = this._properties;\n const animations = [];\n const running = target.$animations || (target.$animations = {});\n const props = Object.keys(values);\n const date = Date.now();\n let i;\n for (i = props.length - 1; i >= 0; --i) {\n const prop = props[i];\n if (prop.charAt(0) === '$') {\n continue;\n }\n if (prop === 'options') {\n animations.push(...this._animateOptions(target, values));\n continue;\n }\n const value = values[prop];\n let animation = running[prop];\n const cfg = animatedProps.get(prop);\n if (animation) {\n if (cfg && animation.active()) {\n animation.update(cfg, value, date);\n continue;\n } else {\n animation.cancel();\n }\n }\n if (!cfg || !cfg.duration) {\n target[prop] = value;\n continue;\n }\n running[prop] = animation = new Animation(cfg, target, prop, value);\n animations.push(animation);\n }\n return animations;\n }\n update(target, values) {\n if (this._properties.size === 0) {\n Object.assign(target, values);\n return;\n }\n const animations = this._createAnimations(target, values);\n if (animations.length) {\n animator.add(this._chart, animations);\n return true;\n }\n }\n}\nfunction awaitAll(animations, properties) {\n const running = [];\n const keys = Object.keys(properties);\n for (let i = 0; i < keys.length; i++) {\n const anim = animations[keys[i]];\n if (anim && anim.active()) {\n running.push(anim.wait());\n }\n }\n return Promise.all(running);\n}\nfunction resolveTargetOptions(target, newOptions) {\n if (!newOptions) {\n return;\n }\n let options = target.options;\n if (!options) {\n target.options = newOptions;\n return;\n }\n if (options.$shared) {\n target.options = options = Object.assign({}, options, {$shared: false, $animations: {}});\n }\n return options;\n}\n\nfunction scaleClip(scale, allowedOverflow) {\n const opts = scale && scale.options || {};\n const reverse = opts.reverse;\n const min = opts.min === undefined ? allowedOverflow : 0;\n const max = opts.max === undefined ? allowedOverflow : 0;\n return {\n start: reverse ? max : min,\n end: reverse ? min : max\n };\n}\nfunction defaultClip(xScale, yScale, allowedOverflow) {\n if (allowedOverflow === false) {\n return false;\n }\n const x = scaleClip(xScale, allowedOverflow);\n const y = scaleClip(yScale, allowedOverflow);\n return {\n top: y.end,\n right: x.end,\n bottom: y.start,\n left: x.start\n };\n}\nfunction toClip(value) {\n let t, r, b, l;\n if (isObject(value)) {\n t = value.top;\n r = value.right;\n b = value.bottom;\n l = value.left;\n } else {\n t = r = b = l = value;\n }\n return {\n top: t,\n right: r,\n bottom: b,\n left: l,\n disabled: value === false\n };\n}\nfunction getSortedDatasetIndices(chart, filterVisible) {\n const keys = [];\n const metasets = chart._getSortedDatasetMetas(filterVisible);\n let i, ilen;\n for (i = 0, ilen = metasets.length; i < ilen; ++i) {\n keys.push(metasets[i].index);\n }\n return keys;\n}\nfunction applyStack(stack, value, dsIndex, options = {}) {\n const keys = stack.keys;\n const singleMode = options.mode === 'single';\n let i, ilen, datasetIndex, otherValue;\n if (value === null) {\n return;\n }\n for (i = 0, ilen = keys.length; i < ilen; ++i) {\n datasetIndex = +keys[i];\n if (datasetIndex === dsIndex) {\n if (options.all) {\n continue;\n }\n break;\n }\n otherValue = stack.values[datasetIndex];\n if (isNumberFinite(otherValue) && (singleMode || (value === 0 || sign(value) === sign(otherValue)))) {\n value += otherValue;\n }\n }\n return value;\n}\nfunction convertObjectDataToArray(data) {\n const keys = Object.keys(data);\n const adata = new Array(keys.length);\n let i, ilen, key;\n for (i = 0, ilen = keys.length; i < ilen; ++i) {\n key = keys[i];\n adata[i] = {\n x: key,\n y: data[key]\n };\n }\n return adata;\n}\nfunction isStacked(scale, meta) {\n const stacked = scale && scale.options.stacked;\n return stacked || (stacked === undefined && meta.stack !== undefined);\n}\nfunction getStackKey(indexScale, valueScale, meta) {\n return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`;\n}\nfunction getUserBounds(scale) {\n const {min, max, minDefined, maxDefined} = scale.getUserBounds();\n return {\n min: minDefined ? min : Number.NEGATIVE_INFINITY,\n max: maxDefined ? max : Number.POSITIVE_INFINITY\n };\n}\nfunction getOrCreateStack(stacks, stackKey, indexValue) {\n const subStack = stacks[stackKey] || (stacks[stackKey] = {});\n return subStack[indexValue] || (subStack[indexValue] = {});\n}\nfunction getLastIndexInStack(stack, vScale, positive, type) {\n for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) {\n const value = stack[meta.index];\n if ((positive && value > 0) || (!positive && value < 0)) {\n return meta.index;\n }\n }\n return null;\n}\nfunction updateStacks(controller, parsed) {\n const {chart, _cachedMeta: meta} = controller;\n const stacks = chart._stacks || (chart._stacks = {});\n const {iScale, vScale, index: datasetIndex} = meta;\n const iAxis = iScale.axis;\n const vAxis = vScale.axis;\n const key = getStackKey(iScale, vScale, meta);\n const ilen = parsed.length;\n let stack;\n for (let i = 0; i < ilen; ++i) {\n const item = parsed[i];\n const {[iAxis]: index, [vAxis]: value} = item;\n const itemStacks = item._stacks || (item._stacks = {});\n stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index);\n stack[datasetIndex] = value;\n stack._top = getLastIndexInStack(stack, vScale, true, meta.type);\n stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type);\n }\n}\nfunction getFirstScaleId(chart, axis) {\n const scales = chart.scales;\n return Object.keys(scales).filter(key => scales[key].axis === axis).shift();\n}\nfunction createDatasetContext(parent, index) {\n return createContext(parent,\n {\n active: false,\n dataset: undefined,\n datasetIndex: index,\n index,\n mode: 'default',\n type: 'dataset'\n }\n );\n}\nfunction createDataContext(parent, index, element) {\n return createContext(parent, {\n active: false,\n dataIndex: index,\n parsed: undefined,\n raw: undefined,\n element,\n index,\n mode: 'default',\n type: 'data'\n });\n}\nfunction clearStacks(meta, items) {\n const datasetIndex = meta.controller.index;\n const axis = meta.vScale && meta.vScale.axis;\n if (!axis) {\n return;\n }\n items = items || meta._parsed;\n for (const parsed of items) {\n const stacks = parsed._stacks;\n if (!stacks || stacks[axis] === undefined || stacks[axis][datasetIndex] === undefined) {\n return;\n }\n delete stacks[axis][datasetIndex];\n }\n}\nconst isDirectUpdateMode = (mode) => mode === 'reset' || mode === 'none';\nconst cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached);\nconst createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked\n && {keys: getSortedDatasetIndices(chart, true), values: null};\nclass DatasetController {\n constructor(chart, datasetIndex) {\n this.chart = chart;\n this._ctx = chart.ctx;\n this.index = datasetIndex;\n this._cachedDataOpts = {};\n this._cachedMeta = this.getMeta();\n this._type = this._cachedMeta.type;\n this.options = undefined;\n this._parsing = false;\n this._data = undefined;\n this._objectData = undefined;\n this._sharedOptions = undefined;\n this._drawStart = undefined;\n this._drawCount = undefined;\n this.enableOptionSharing = false;\n this.supportsDecimation = false;\n this.$context = undefined;\n this._syncList = [];\n this.initialize();\n }\n initialize() {\n const meta = this._cachedMeta;\n this.configure();\n this.linkScales();\n meta._stacked = isStacked(meta.vScale, meta);\n this.addElements();\n }\n updateIndex(datasetIndex) {\n if (this.index !== datasetIndex) {\n clearStacks(this._cachedMeta);\n }\n this.index = datasetIndex;\n }\n linkScales() {\n const chart = this.chart;\n const meta = this._cachedMeta;\n const dataset = this.getDataset();\n const chooseId = (axis, x, y, r) => axis === 'x' ? x : axis === 'r' ? r : y;\n const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x'));\n const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y'));\n const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r'));\n const indexAxis = meta.indexAxis;\n const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid);\n const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid);\n meta.xScale = this.getScaleForId(xid);\n meta.yScale = this.getScaleForId(yid);\n meta.rScale = this.getScaleForId(rid);\n meta.iScale = this.getScaleForId(iid);\n meta.vScale = this.getScaleForId(vid);\n }\n getDataset() {\n return this.chart.data.datasets[this.index];\n }\n getMeta() {\n return this.chart.getDatasetMeta(this.index);\n }\n getScaleForId(scaleID) {\n return this.chart.scales[scaleID];\n }\n _getOtherScale(scale) {\n const meta = this._cachedMeta;\n return scale === meta.iScale\n ? meta.vScale\n : meta.iScale;\n }\n reset() {\n this._update('reset');\n }\n _destroy() {\n const meta = this._cachedMeta;\n if (this._data) {\n unlistenArrayEvents(this._data, this);\n }\n if (meta._stacked) {\n clearStacks(meta);\n }\n }\n _dataCheck() {\n const dataset = this.getDataset();\n const data = dataset.data || (dataset.data = []);\n const _data = this._data;\n if (isObject(data)) {\n this._data = convertObjectDataToArray(data);\n } else if (_data !== data) {\n if (_data) {\n unlistenArrayEvents(_data, this);\n const meta = this._cachedMeta;\n clearStacks(meta);\n meta._parsed = [];\n }\n if (data && Object.isExtensible(data)) {\n listenArrayEvents(data, this);\n }\n this._syncList = [];\n this._data = data;\n }\n }\n addElements() {\n const meta = this._cachedMeta;\n this._dataCheck();\n if (this.datasetElementType) {\n meta.dataset = new this.datasetElementType();\n }\n }\n buildOrUpdateElements(resetNewElements) {\n const meta = this._cachedMeta;\n const dataset = this.getDataset();\n let stackChanged = false;\n this._dataCheck();\n const oldStacked = meta._stacked;\n meta._stacked = isStacked(meta.vScale, meta);\n if (meta.stack !== dataset.stack) {\n stackChanged = true;\n clearStacks(meta);\n meta.stack = dataset.stack;\n }\n this._resyncElements(resetNewElements);\n if (stackChanged || oldStacked !== meta._stacked) {\n updateStacks(this, meta._parsed);\n }\n }\n configure() {\n const config = this.chart.config;\n const scopeKeys = config.datasetScopeKeys(this._type);\n const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);\n this.options = config.createResolver(scopes, this.getContext());\n this._parsing = this.options.parsing;\n this._cachedDataOpts = {};\n }\n parse(start, count) {\n const {_cachedMeta: meta, _data: data} = this;\n const {iScale, _stacked} = meta;\n const iAxis = iScale.axis;\n let sorted = start === 0 && count === data.length ? true : meta._sorted;\n let prev = start > 0 && meta._parsed[start - 1];\n let i, cur, parsed;\n if (this._parsing === false) {\n meta._parsed = data;\n meta._sorted = true;\n parsed = data;\n } else {\n if (isArray(data[start])) {\n parsed = this.parseArrayData(meta, data, start, count);\n } else if (isObject(data[start])) {\n parsed = this.parseObjectData(meta, data, start, count);\n } else {\n parsed = this.parsePrimitiveData(meta, data, start, count);\n }\n const isNotInOrderComparedToPrev = () => cur[iAxis] === null || (prev && cur[iAxis] < prev[iAxis]);\n for (i = 0; i < count; ++i) {\n meta._parsed[i + start] = cur = parsed[i];\n if (sorted) {\n if (isNotInOrderComparedToPrev()) {\n sorted = false;\n }\n prev = cur;\n }\n }\n meta._sorted = sorted;\n }\n if (_stacked) {\n updateStacks(this, parsed);\n }\n }\n parsePrimitiveData(meta, data, start, count) {\n const {iScale, vScale} = meta;\n const iAxis = iScale.axis;\n const vAxis = vScale.axis;\n const labels = iScale.getLabels();\n const singleScale = iScale === vScale;\n const parsed = new Array(count);\n let i, ilen, index;\n for (i = 0, ilen = count; i < ilen; ++i) {\n index = i + start;\n parsed[i] = {\n [iAxis]: singleScale || iScale.parse(labels[index], index),\n [vAxis]: vScale.parse(data[index], index)\n };\n }\n return parsed;\n }\n parseArrayData(meta, data, start, count) {\n const {xScale, yScale} = meta;\n const parsed = new Array(count);\n let i, ilen, index, item;\n for (i = 0, ilen = count; i < ilen; ++i) {\n index = i + start;\n item = data[index];\n parsed[i] = {\n x: xScale.parse(item[0], index),\n y: yScale.parse(item[1], index)\n };\n }\n return parsed;\n }\n parseObjectData(meta, data, start, count) {\n const {xScale, yScale} = meta;\n const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;\n const parsed = new Array(count);\n let i, ilen, index, item;\n for (i = 0, ilen = count; i < ilen; ++i) {\n index = i + start;\n item = data[index];\n parsed[i] = {\n x: xScale.parse(resolveObjectKey(item, xAxisKey), index),\n y: yScale.parse(resolveObjectKey(item, yAxisKey), index)\n };\n }\n return parsed;\n }\n getParsed(index) {\n return this._cachedMeta._parsed[index];\n }\n getDataElement(index) {\n return this._cachedMeta.data[index];\n }\n applyStack(scale, parsed, mode) {\n const chart = this.chart;\n const meta = this._cachedMeta;\n const value = parsed[scale.axis];\n const stack = {\n keys: getSortedDatasetIndices(chart, true),\n values: parsed._stacks[scale.axis]\n };\n return applyStack(stack, value, meta.index, {mode});\n }\n updateRangeFromParsed(range, scale, parsed, stack) {\n const parsedValue = parsed[scale.axis];\n let value = parsedValue === null ? NaN : parsedValue;\n const values = stack && parsed._stacks[scale.axis];\n if (stack && values) {\n stack.values = values;\n value = applyStack(stack, parsedValue, this._cachedMeta.index);\n }\n range.min = Math.min(range.min, value);\n range.max = Math.max(range.max, value);\n }\n getMinMax(scale, canStack) {\n const meta = this._cachedMeta;\n const _parsed = meta._parsed;\n const sorted = meta._sorted && scale === meta.iScale;\n const ilen = _parsed.length;\n const otherScale = this._getOtherScale(scale);\n const stack = createStack(canStack, meta, this.chart);\n const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY};\n const {min: otherMin, max: otherMax} = getUserBounds(otherScale);\n let i, parsed;\n function _skip() {\n parsed = _parsed[i];\n const otherValue = parsed[otherScale.axis];\n return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue;\n }\n for (i = 0; i < ilen; ++i) {\n if (_skip()) {\n continue;\n }\n this.updateRangeFromParsed(range, scale, parsed, stack);\n if (sorted) {\n break;\n }\n }\n if (sorted) {\n for (i = ilen - 1; i >= 0; --i) {\n if (_skip()) {\n continue;\n }\n this.updateRangeFromParsed(range, scale, parsed, stack);\n break;\n }\n }\n return range;\n }\n getAllParsedValues(scale) {\n const parsed = this._cachedMeta._parsed;\n const values = [];\n let i, ilen, value;\n for (i = 0, ilen = parsed.length; i < ilen; ++i) {\n value = parsed[i][scale.axis];\n if (isNumberFinite(value)) {\n values.push(value);\n }\n }\n return values;\n }\n getMaxOverflow() {\n return false;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const iScale = meta.iScale;\n const vScale = meta.vScale;\n const parsed = this.getParsed(index);\n return {\n label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '',\n value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : ''\n };\n }\n _update(mode) {\n const meta = this._cachedMeta;\n this.update(mode || 'default');\n meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));\n }\n update(mode) {}\n draw() {\n const ctx = this._ctx;\n const chart = this.chart;\n const meta = this._cachedMeta;\n const elements = meta.data || [];\n const area = chart.chartArea;\n const active = [];\n const start = this._drawStart || 0;\n const count = this._drawCount || (elements.length - start);\n const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;\n let i;\n if (meta.dataset) {\n meta.dataset.draw(ctx, area, start, count);\n }\n for (i = start; i < start + count; ++i) {\n const element = elements[i];\n if (element.hidden) {\n continue;\n }\n if (element.active && drawActiveElementsOnTop) {\n active.push(element);\n } else {\n element.draw(ctx, area);\n }\n }\n for (i = 0; i < active.length; ++i) {\n active[i].draw(ctx, area);\n }\n }\n getStyle(index, active) {\n const mode = active ? 'active' : 'default';\n return index === undefined && this._cachedMeta.dataset\n ? this.resolveDatasetElementOptions(mode)\n : this.resolveDataElementOptions(index || 0, mode);\n }\n getContext(index, active, mode) {\n const dataset = this.getDataset();\n let context;\n if (index >= 0 && index < this._cachedMeta.data.length) {\n const element = this._cachedMeta.data[index];\n context = element.$context ||\n (element.$context = createDataContext(this.getContext(), index, element));\n context.parsed = this.getParsed(index);\n context.raw = dataset.data[index];\n context.index = context.dataIndex = index;\n } else {\n context = this.$context ||\n (this.$context = createDatasetContext(this.chart.getContext(), this.index));\n context.dataset = dataset;\n context.index = context.datasetIndex = this.index;\n }\n context.active = !!active;\n context.mode = mode;\n return context;\n }\n resolveDatasetElementOptions(mode) {\n return this._resolveElementOptions(this.datasetElementType.id, mode);\n }\n resolveDataElementOptions(index, mode) {\n return this._resolveElementOptions(this.dataElementType.id, mode, index);\n }\n _resolveElementOptions(elementType, mode = 'default', index) {\n const active = mode === 'active';\n const cache = this._cachedDataOpts;\n const cacheKey = elementType + '-' + mode;\n const cached = cache[cacheKey];\n const sharing = this.enableOptionSharing && defined(index);\n if (cached) {\n return cloneIfNotShared(cached, sharing);\n }\n const config = this.chart.config;\n const scopeKeys = config.datasetElementScopeKeys(this._type, elementType);\n const prefixes = active ? [`${elementType}Hover`, 'hover', elementType, ''] : [elementType, ''];\n const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);\n const names = Object.keys(defaults.elements[elementType]);\n const context = () => this.getContext(index, active);\n const values = config.resolveNamedOptions(scopes, names, context, prefixes);\n if (values.$shared) {\n values.$shared = sharing;\n cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing));\n }\n return values;\n }\n _resolveAnimations(index, transition, active) {\n const chart = this.chart;\n const cache = this._cachedDataOpts;\n const cacheKey = `animation-${transition}`;\n const cached = cache[cacheKey];\n if (cached) {\n return cached;\n }\n let options;\n if (chart.options.animation !== false) {\n const config = this.chart.config;\n const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition);\n const scopes = config.getOptionScopes(this.getDataset(), scopeKeys);\n options = config.createResolver(scopes, this.getContext(index, active, transition));\n }\n const animations = new Animations(chart, options && options.animations);\n if (options && options._cacheable) {\n cache[cacheKey] = Object.freeze(animations);\n }\n return animations;\n }\n getSharedOptions(options) {\n if (!options.$shared) {\n return;\n }\n return this._sharedOptions || (this._sharedOptions = Object.assign({}, options));\n }\n includeOptions(mode, sharedOptions) {\n return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled;\n }\n updateElement(element, index, properties, mode) {\n if (isDirectUpdateMode(mode)) {\n Object.assign(element, properties);\n } else {\n this._resolveAnimations(index, mode).update(element, properties);\n }\n }\n updateSharedOptions(sharedOptions, mode, newOptions) {\n if (sharedOptions && !isDirectUpdateMode(mode)) {\n this._resolveAnimations(undefined, mode).update(sharedOptions, newOptions);\n }\n }\n _setStyle(element, index, mode, active) {\n element.active = active;\n const options = this.getStyle(index, active);\n this._resolveAnimations(index, mode, active).update(element, {\n options: (!active && this.getSharedOptions(options)) || options\n });\n }\n removeHoverStyle(element, datasetIndex, index) {\n this._setStyle(element, index, 'active', false);\n }\n setHoverStyle(element, datasetIndex, index) {\n this._setStyle(element, index, 'active', true);\n }\n _removeDatasetHoverStyle() {\n const element = this._cachedMeta.dataset;\n if (element) {\n this._setStyle(element, undefined, 'active', false);\n }\n }\n _setDatasetHoverStyle() {\n const element = this._cachedMeta.dataset;\n if (element) {\n this._setStyle(element, undefined, 'active', true);\n }\n }\n _resyncElements(resetNewElements) {\n const data = this._data;\n const elements = this._cachedMeta.data;\n for (const [method, arg1, arg2] of this._syncList) {\n this[method](arg1, arg2);\n }\n this._syncList = [];\n const numMeta = elements.length;\n const numData = data.length;\n const count = Math.min(numData, numMeta);\n if (count) {\n this.parse(0, count);\n }\n if (numData > numMeta) {\n this._insertElements(numMeta, numData - numMeta, resetNewElements);\n } else if (numData < numMeta) {\n this._removeElements(numData, numMeta - numData);\n }\n }\n _insertElements(start, count, resetNewElements = true) {\n const meta = this._cachedMeta;\n const data = meta.data;\n const end = start + count;\n let i;\n const move = (arr) => {\n arr.length += count;\n for (i = arr.length - 1; i >= end; i--) {\n arr[i] = arr[i - count];\n }\n };\n move(data);\n for (i = start; i < end; ++i) {\n data[i] = new this.dataElementType();\n }\n if (this._parsing) {\n move(meta._parsed);\n }\n this.parse(start, count);\n if (resetNewElements) {\n this.updateElements(data, start, count, 'reset');\n }\n }\n updateElements(element, start, count, mode) {}\n _removeElements(start, count) {\n const meta = this._cachedMeta;\n if (this._parsing) {\n const removed = meta._parsed.splice(start, count);\n if (meta._stacked) {\n clearStacks(meta, removed);\n }\n }\n meta.data.splice(start, count);\n }\n _sync(args) {\n if (this._parsing) {\n this._syncList.push(args);\n } else {\n const [method, arg1, arg2] = args;\n this[method](arg1, arg2);\n }\n this.chart._dataChanges.push([this.index, ...args]);\n }\n _onDataPush() {\n const count = arguments.length;\n this._sync(['_insertElements', this.getDataset().data.length - count, count]);\n }\n _onDataPop() {\n this._sync(['_removeElements', this._cachedMeta.data.length - 1, 1]);\n }\n _onDataShift() {\n this._sync(['_removeElements', 0, 1]);\n }\n _onDataSplice(start, count) {\n if (count) {\n this._sync(['_removeElements', start, count]);\n }\n const newCount = arguments.length - 2;\n if (newCount) {\n this._sync(['_insertElements', start, newCount]);\n }\n }\n _onDataUnshift() {\n this._sync(['_insertElements', 0, arguments.length]);\n }\n}\nDatasetController.defaults = {};\nDatasetController.prototype.datasetElementType = null;\nDatasetController.prototype.dataElementType = null;\n\nfunction getAllScaleValues(scale, type) {\n if (!scale._cache.$bar) {\n const visibleMetas = scale.getMatchingVisibleMetas(type);\n let values = [];\n for (let i = 0, ilen = visibleMetas.length; i < ilen; i++) {\n values = values.concat(visibleMetas[i].controller.getAllParsedValues(scale));\n }\n scale._cache.$bar = _arrayUnique(values.sort((a, b) => a - b));\n }\n return scale._cache.$bar;\n}\nfunction computeMinSampleSize(meta) {\n const scale = meta.iScale;\n const values = getAllScaleValues(scale, meta.type);\n let min = scale._length;\n let i, ilen, curr, prev;\n const updateMinAndPrev = () => {\n if (curr === 32767 || curr === -32768) {\n return;\n }\n if (defined(prev)) {\n min = Math.min(min, Math.abs(curr - prev) || min);\n }\n prev = curr;\n };\n for (i = 0, ilen = values.length; i < ilen; ++i) {\n curr = scale.getPixelForValue(values[i]);\n updateMinAndPrev();\n }\n prev = undefined;\n for (i = 0, ilen = scale.ticks.length; i < ilen; ++i) {\n curr = scale.getPixelForTick(i);\n updateMinAndPrev();\n }\n return min;\n}\nfunction computeFitCategoryTraits(index, ruler, options, stackCount) {\n const thickness = options.barThickness;\n let size, ratio;\n if (isNullOrUndef(thickness)) {\n size = ruler.min * options.categoryPercentage;\n ratio = options.barPercentage;\n } else {\n size = thickness * stackCount;\n ratio = 1;\n }\n return {\n chunk: size / stackCount,\n ratio,\n start: ruler.pixels[index] - (size / 2)\n };\n}\nfunction computeFlexCategoryTraits(index, ruler, options, stackCount) {\n const pixels = ruler.pixels;\n const curr = pixels[index];\n let prev = index > 0 ? pixels[index - 1] : null;\n let next = index < pixels.length - 1 ? pixels[index + 1] : null;\n const percent = options.categoryPercentage;\n if (prev === null) {\n prev = curr - (next === null ? ruler.end - ruler.start : next - curr);\n }\n if (next === null) {\n next = curr + curr - prev;\n }\n const start = curr - (curr - Math.min(prev, next)) / 2 * percent;\n const size = Math.abs(next - prev) / 2 * percent;\n return {\n chunk: size / stackCount,\n ratio: options.barPercentage,\n start\n };\n}\nfunction parseFloatBar(entry, item, vScale, i) {\n const startValue = vScale.parse(entry[0], i);\n const endValue = vScale.parse(entry[1], i);\n const min = Math.min(startValue, endValue);\n const max = Math.max(startValue, endValue);\n let barStart = min;\n let barEnd = max;\n if (Math.abs(min) > Math.abs(max)) {\n barStart = max;\n barEnd = min;\n }\n item[vScale.axis] = barEnd;\n item._custom = {\n barStart,\n barEnd,\n start: startValue,\n end: endValue,\n min,\n max\n };\n}\nfunction parseValue(entry, item, vScale, i) {\n if (isArray(entry)) {\n parseFloatBar(entry, item, vScale, i);\n } else {\n item[vScale.axis] = vScale.parse(entry, i);\n }\n return item;\n}\nfunction parseArrayOrPrimitive(meta, data, start, count) {\n const iScale = meta.iScale;\n const vScale = meta.vScale;\n const labels = iScale.getLabels();\n const singleScale = iScale === vScale;\n const parsed = [];\n let i, ilen, item, entry;\n for (i = start, ilen = start + count; i < ilen; ++i) {\n entry = data[i];\n item = {};\n item[iScale.axis] = singleScale || iScale.parse(labels[i], i);\n parsed.push(parseValue(entry, item, vScale, i));\n }\n return parsed;\n}\nfunction isFloatBar(custom) {\n return custom && custom.barStart !== undefined && custom.barEnd !== undefined;\n}\nfunction barSign(size, vScale, actualBase) {\n if (size !== 0) {\n return sign(size);\n }\n return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1);\n}\nfunction borderProps(properties) {\n let reverse, start, end, top, bottom;\n if (properties.horizontal) {\n reverse = properties.base > properties.x;\n start = 'left';\n end = 'right';\n } else {\n reverse = properties.base < properties.y;\n start = 'bottom';\n end = 'top';\n }\n if (reverse) {\n top = 'end';\n bottom = 'start';\n } else {\n top = 'start';\n bottom = 'end';\n }\n return {start, end, reverse, top, bottom};\n}\nfunction setBorderSkipped(properties, options, stack, index) {\n let edge = options.borderSkipped;\n const res = {};\n if (!edge) {\n properties.borderSkipped = res;\n return;\n }\n const {start, end, reverse, top, bottom} = borderProps(properties);\n if (edge === 'middle' && stack) {\n properties.enableBorderRadius = true;\n if ((stack._top || 0) === index) {\n edge = top;\n } else if ((stack._bottom || 0) === index) {\n edge = bottom;\n } else {\n res[parseEdge(bottom, start, end, reverse)] = true;\n edge = top;\n }\n }\n res[parseEdge(edge, start, end, reverse)] = true;\n properties.borderSkipped = res;\n}\nfunction parseEdge(edge, a, b, reverse) {\n if (reverse) {\n edge = swap(edge, a, b);\n edge = startEnd(edge, b, a);\n } else {\n edge = startEnd(edge, a, b);\n }\n return edge;\n}\nfunction swap(orig, v1, v2) {\n return orig === v1 ? v2 : orig === v2 ? v1 : orig;\n}\nfunction startEnd(v, start, end) {\n return v === 'start' ? start : v === 'end' ? end : v;\n}\nfunction setInflateAmount(properties, {inflateAmount}, ratio) {\n properties.inflateAmount = inflateAmount === 'auto'\n ? ratio === 1 ? 0.33 : 0\n : inflateAmount;\n}\nclass BarController extends DatasetController {\n parsePrimitiveData(meta, data, start, count) {\n return parseArrayOrPrimitive(meta, data, start, count);\n }\n parseArrayData(meta, data, start, count) {\n return parseArrayOrPrimitive(meta, data, start, count);\n }\n parseObjectData(meta, data, start, count) {\n const {iScale, vScale} = meta;\n const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing;\n const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey;\n const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey;\n const parsed = [];\n let i, ilen, item, obj;\n for (i = start, ilen = start + count; i < ilen; ++i) {\n obj = data[i];\n item = {};\n item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i);\n parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i));\n }\n return parsed;\n }\n updateRangeFromParsed(range, scale, parsed, stack) {\n super.updateRangeFromParsed(range, scale, parsed, stack);\n const custom = parsed._custom;\n if (custom && scale === this._cachedMeta.vScale) {\n range.min = Math.min(range.min, custom.min);\n range.max = Math.max(range.max, custom.max);\n }\n }\n getMaxOverflow() {\n return 0;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const {iScale, vScale} = meta;\n const parsed = this.getParsed(index);\n const custom = parsed._custom;\n const value = isFloatBar(custom)\n ? '[' + custom.start + ', ' + custom.end + ']'\n : '' + vScale.getLabelForValue(parsed[vScale.axis]);\n return {\n label: '' + iScale.getLabelForValue(parsed[iScale.axis]),\n value\n };\n }\n initialize() {\n this.enableOptionSharing = true;\n super.initialize();\n const meta = this._cachedMeta;\n meta.stack = this.getDataset().stack;\n }\n update(mode) {\n const meta = this._cachedMeta;\n this.updateElements(meta.data, 0, meta.data.length, mode);\n }\n updateElements(bars, start, count, mode) {\n const reset = mode === 'reset';\n const {index, _cachedMeta: {vScale}} = this;\n const base = vScale.getBasePixel();\n const horizontal = vScale.isHorizontal();\n const ruler = this._getRuler();\n const firstOpts = this.resolveDataElementOptions(start, mode);\n const sharedOptions = this.getSharedOptions(firstOpts);\n const includeOptions = this.includeOptions(mode, sharedOptions);\n this.updateSharedOptions(sharedOptions, mode, firstOpts);\n for (let i = start; i < start + count; i++) {\n const parsed = this.getParsed(i);\n const vpixels = reset || isNullOrUndef(parsed[vScale.axis]) ? {base, head: base} : this._calculateBarValuePixels(i);\n const ipixels = this._calculateBarIndexPixels(i, ruler);\n const stack = (parsed._stacks || {})[vScale.axis];\n const properties = {\n horizontal,\n base: vpixels.base,\n enableBorderRadius: !stack || isFloatBar(parsed._custom) || (index === stack._top || index === stack._bottom),\n x: horizontal ? vpixels.head : ipixels.center,\n y: horizontal ? ipixels.center : vpixels.head,\n height: horizontal ? ipixels.size : Math.abs(vpixels.size),\n width: horizontal ? Math.abs(vpixels.size) : ipixels.size\n };\n if (includeOptions) {\n properties.options = sharedOptions || this.resolveDataElementOptions(i, bars[i].active ? 'active' : mode);\n }\n const options = properties.options || bars[i].options;\n setBorderSkipped(properties, options, stack, index);\n setInflateAmount(properties, options, ruler.ratio);\n this.updateElement(bars[i], i, properties, mode);\n }\n }\n _getStacks(last, dataIndex) {\n const meta = this._cachedMeta;\n const iScale = meta.iScale;\n const metasets = iScale.getMatchingVisibleMetas(this._type);\n const stacked = iScale.options.stacked;\n const ilen = metasets.length;\n const stacks = [];\n let i, item;\n for (i = 0; i < ilen; ++i) {\n item = metasets[i];\n if (!item.controller.options.grouped) {\n continue;\n }\n if (typeof dataIndex !== 'undefined') {\n const val = item.controller.getParsed(dataIndex)[\n item.controller._cachedMeta.vScale.axis\n ];\n if (isNullOrUndef(val) || isNaN(val)) {\n continue;\n }\n }\n if (stacked === false || stacks.indexOf(item.stack) === -1 ||\n\t\t\t\t(stacked === undefined && item.stack === undefined)) {\n stacks.push(item.stack);\n }\n if (item.index === last) {\n break;\n }\n }\n if (!stacks.length) {\n stacks.push(undefined);\n }\n return stacks;\n }\n _getStackCount(index) {\n return this._getStacks(undefined, index).length;\n }\n _getStackIndex(datasetIndex, name, dataIndex) {\n const stacks = this._getStacks(datasetIndex, dataIndex);\n const index = (name !== undefined)\n ? stacks.indexOf(name)\n : -1;\n return (index === -1)\n ? stacks.length - 1\n : index;\n }\n _getRuler() {\n const opts = this.options;\n const meta = this._cachedMeta;\n const iScale = meta.iScale;\n const pixels = [];\n let i, ilen;\n for (i = 0, ilen = meta.data.length; i < ilen; ++i) {\n pixels.push(iScale.getPixelForValue(this.getParsed(i)[iScale.axis], i));\n }\n const barThickness = opts.barThickness;\n const min = barThickness || computeMinSampleSize(meta);\n return {\n min,\n pixels,\n start: iScale._startPixel,\n end: iScale._endPixel,\n stackCount: this._getStackCount(),\n scale: iScale,\n grouped: opts.grouped,\n ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage\n };\n }\n _calculateBarValuePixels(index) {\n const {_cachedMeta: {vScale, _stacked}, options: {base: baseValue, minBarLength}} = this;\n const actualBase = baseValue || 0;\n const parsed = this.getParsed(index);\n const custom = parsed._custom;\n const floating = isFloatBar(custom);\n let value = parsed[vScale.axis];\n let start = 0;\n let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value;\n let head, size;\n if (length !== value) {\n start = length - value;\n length = value;\n }\n if (floating) {\n value = custom.barStart;\n length = custom.barEnd - custom.barStart;\n if (value !== 0 && sign(value) !== sign(custom.barEnd)) {\n start = 0;\n }\n start += value;\n }\n const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start;\n let base = vScale.getPixelForValue(startValue);\n if (this.chart.getDataVisibility(index)) {\n head = vScale.getPixelForValue(start + length);\n } else {\n head = base;\n }\n size = head - base;\n if (Math.abs(size) < minBarLength) {\n size = barSign(size, vScale, actualBase) * minBarLength;\n if (value === actualBase) {\n base -= size / 2;\n }\n const startPixel = vScale.getPixelForDecimal(0);\n const endPixel = vScale.getPixelForDecimal(1);\n const min = Math.min(startPixel, endPixel);\n const max = Math.max(startPixel, endPixel);\n base = Math.max(Math.min(base, max), min);\n head = base + size;\n }\n if (base === vScale.getPixelForValue(actualBase)) {\n const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2;\n base += halfGrid;\n size -= halfGrid;\n }\n return {\n size,\n base,\n head,\n center: head + size / 2\n };\n }\n _calculateBarIndexPixels(index, ruler) {\n const scale = ruler.scale;\n const options = this.options;\n const skipNull = options.skipNull;\n const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity);\n let center, size;\n if (ruler.grouped) {\n const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount;\n const range = options.barThickness === 'flex'\n ? computeFlexCategoryTraits(index, ruler, options, stackCount)\n : computeFitCategoryTraits(index, ruler, options, stackCount);\n const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : undefined);\n center = range.start + (range.chunk * stackIndex) + (range.chunk / 2);\n size = Math.min(maxBarThickness, range.chunk * range.ratio);\n } else {\n center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index);\n size = Math.min(maxBarThickness, ruler.min * ruler.ratio);\n }\n return {\n base: center - size / 2,\n head: center + size / 2,\n center,\n size\n };\n }\n draw() {\n const meta = this._cachedMeta;\n const vScale = meta.vScale;\n const rects = meta.data;\n const ilen = rects.length;\n let i = 0;\n for (; i < ilen; ++i) {\n if (this.getParsed(i)[vScale.axis] !== null) {\n rects[i].draw(this._ctx);\n }\n }\n }\n}\nBarController.id = 'bar';\nBarController.defaults = {\n datasetElementType: false,\n dataElementType: 'bar',\n categoryPercentage: 0.8,\n barPercentage: 0.9,\n grouped: true,\n animations: {\n numbers: {\n type: 'number',\n properties: ['x', 'y', 'base', 'width', 'height']\n }\n }\n};\nBarController.overrides = {\n scales: {\n _index_: {\n type: 'category',\n offset: true,\n grid: {\n offset: true\n }\n },\n _value_: {\n type: 'linear',\n beginAtZero: true,\n }\n }\n};\n\nclass BubbleController extends DatasetController {\n initialize() {\n this.enableOptionSharing = true;\n super.initialize();\n }\n parsePrimitiveData(meta, data, start, count) {\n const parsed = super.parsePrimitiveData(meta, data, start, count);\n for (let i = 0; i < parsed.length; i++) {\n parsed[i]._custom = this.resolveDataElementOptions(i + start).radius;\n }\n return parsed;\n }\n parseArrayData(meta, data, start, count) {\n const parsed = super.parseArrayData(meta, data, start, count);\n for (let i = 0; i < parsed.length; i++) {\n const item = data[start + i];\n parsed[i]._custom = valueOrDefault(item[2], this.resolveDataElementOptions(i + start).radius);\n }\n return parsed;\n }\n parseObjectData(meta, data, start, count) {\n const parsed = super.parseObjectData(meta, data, start, count);\n for (let i = 0; i < parsed.length; i++) {\n const item = data[start + i];\n parsed[i]._custom = valueOrDefault(item && item.r && +item.r, this.resolveDataElementOptions(i + start).radius);\n }\n return parsed;\n }\n getMaxOverflow() {\n const data = this._cachedMeta.data;\n let max = 0;\n for (let i = data.length - 1; i >= 0; --i) {\n max = Math.max(max, data[i].size(this.resolveDataElementOptions(i)) / 2);\n }\n return max > 0 && max;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const {xScale, yScale} = meta;\n const parsed = this.getParsed(index);\n const x = xScale.getLabelForValue(parsed.x);\n const y = yScale.getLabelForValue(parsed.y);\n const r = parsed._custom;\n return {\n label: meta.label,\n value: '(' + x + ', ' + y + (r ? ', ' + r : '') + ')'\n };\n }\n update(mode) {\n const points = this._cachedMeta.data;\n this.updateElements(points, 0, points.length, mode);\n }\n updateElements(points, start, count, mode) {\n const reset = mode === 'reset';\n const {iScale, vScale} = this._cachedMeta;\n const firstOpts = this.resolveDataElementOptions(start, mode);\n const sharedOptions = this.getSharedOptions(firstOpts);\n const includeOptions = this.includeOptions(mode, sharedOptions);\n const iAxis = iScale.axis;\n const vAxis = vScale.axis;\n for (let i = start; i < start + count; i++) {\n const point = points[i];\n const parsed = !reset && this.getParsed(i);\n const properties = {};\n const iPixel = properties[iAxis] = reset ? iScale.getPixelForDecimal(0.5) : iScale.getPixelForValue(parsed[iAxis]);\n const vPixel = properties[vAxis] = reset ? vScale.getBasePixel() : vScale.getPixelForValue(parsed[vAxis]);\n properties.skip = isNaN(iPixel) || isNaN(vPixel);\n if (includeOptions) {\n properties.options = this.resolveDataElementOptions(i, point.active ? 'active' : mode);\n if (reset) {\n properties.options.radius = 0;\n }\n }\n this.updateElement(point, i, properties, mode);\n }\n this.updateSharedOptions(sharedOptions, mode, firstOpts);\n }\n resolveDataElementOptions(index, mode) {\n const parsed = this.getParsed(index);\n let values = super.resolveDataElementOptions(index, mode);\n if (values.$shared) {\n values = Object.assign({}, values, {$shared: false});\n }\n const radius = values.radius;\n if (mode !== 'active') {\n values.radius = 0;\n }\n values.radius += valueOrDefault(parsed && parsed._custom, radius);\n return values;\n }\n}\nBubbleController.id = 'bubble';\nBubbleController.defaults = {\n datasetElementType: false,\n dataElementType: 'point',\n animations: {\n numbers: {\n type: 'number',\n properties: ['x', 'y', 'borderWidth', 'radius']\n }\n }\n};\nBubbleController.overrides = {\n scales: {\n x: {\n type: 'linear'\n },\n y: {\n type: 'linear'\n }\n },\n plugins: {\n tooltip: {\n callbacks: {\n title() {\n return '';\n }\n }\n }\n }\n};\n\nfunction getRatioAndOffset(rotation, circumference, cutout) {\n let ratioX = 1;\n let ratioY = 1;\n let offsetX = 0;\n let offsetY = 0;\n if (circumference < TAU) {\n const startAngle = rotation;\n const endAngle = startAngle + circumference;\n const startX = Math.cos(startAngle);\n const startY = Math.sin(startAngle);\n const endX = Math.cos(endAngle);\n const endY = Math.sin(endAngle);\n const calcMax = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a, a * cutout, b, b * cutout);\n const calcMin = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a, a * cutout, b, b * cutout);\n const maxX = calcMax(0, startX, endX);\n const maxY = calcMax(HALF_PI, startY, endY);\n const minX = calcMin(PI, startX, endX);\n const minY = calcMin(PI + HALF_PI, startY, endY);\n ratioX = (maxX - minX) / 2;\n ratioY = (maxY - minY) / 2;\n offsetX = -(maxX + minX) / 2;\n offsetY = -(maxY + minY) / 2;\n }\n return {ratioX, ratioY, offsetX, offsetY};\n}\nclass DoughnutController extends DatasetController {\n constructor(chart, datasetIndex) {\n super(chart, datasetIndex);\n this.enableOptionSharing = true;\n this.innerRadius = undefined;\n this.outerRadius = undefined;\n this.offsetX = undefined;\n this.offsetY = undefined;\n }\n linkScales() {}\n parse(start, count) {\n const data = this.getDataset().data;\n const meta = this._cachedMeta;\n if (this._parsing === false) {\n meta._parsed = data;\n } else {\n let getter = (i) => +data[i];\n if (isObject(data[start])) {\n const {key = 'value'} = this._parsing;\n getter = (i) => +resolveObjectKey(data[i], key);\n }\n let i, ilen;\n for (i = start, ilen = start + count; i < ilen; ++i) {\n meta._parsed[i] = getter(i);\n }\n }\n }\n _getRotation() {\n return toRadians(this.options.rotation - 90);\n }\n _getCircumference() {\n return toRadians(this.options.circumference);\n }\n _getRotationExtents() {\n let min = TAU;\n let max = -TAU;\n for (let i = 0; i < this.chart.data.datasets.length; ++i) {\n if (this.chart.isDatasetVisible(i)) {\n const controller = this.chart.getDatasetMeta(i).controller;\n const rotation = controller._getRotation();\n const circumference = controller._getCircumference();\n min = Math.min(min, rotation);\n max = Math.max(max, rotation + circumference);\n }\n }\n return {\n rotation: min,\n circumference: max - min,\n };\n }\n update(mode) {\n const chart = this.chart;\n const {chartArea} = chart;\n const meta = this._cachedMeta;\n const arcs = meta.data;\n const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing;\n const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0);\n const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1);\n const chartWeight = this._getRingWeight(this.index);\n const {circumference, rotation} = this._getRotationExtents();\n const {ratioX, ratioY, offsetX, offsetY} = getRatioAndOffset(rotation, circumference, cutout);\n const maxWidth = (chartArea.width - spacing) / ratioX;\n const maxHeight = (chartArea.height - spacing) / ratioY;\n const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0);\n const outerRadius = toDimension(this.options.radius, maxRadius);\n const innerRadius = Math.max(outerRadius * cutout, 0);\n const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal();\n this.offsetX = offsetX * outerRadius;\n this.offsetY = offsetY * outerRadius;\n meta.total = this.calculateTotal();\n this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index);\n this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0);\n this.updateElements(arcs, 0, arcs.length, mode);\n }\n _circumference(i, reset) {\n const opts = this.options;\n const meta = this._cachedMeta;\n const circumference = this._getCircumference();\n if ((reset && opts.animation.animateRotate) || !this.chart.getDataVisibility(i) || meta._parsed[i] === null || meta.data[i].hidden) {\n return 0;\n }\n return this.calculateCircumference(meta._parsed[i] * circumference / TAU);\n }\n updateElements(arcs, start, count, mode) {\n const reset = mode === 'reset';\n const chart = this.chart;\n const chartArea = chart.chartArea;\n const opts = chart.options;\n const animationOpts = opts.animation;\n const centerX = (chartArea.left + chartArea.right) / 2;\n const centerY = (chartArea.top + chartArea.bottom) / 2;\n const animateScale = reset && animationOpts.animateScale;\n const innerRadius = animateScale ? 0 : this.innerRadius;\n const outerRadius = animateScale ? 0 : this.outerRadius;\n const firstOpts = this.resolveDataElementOptions(start, mode);\n const sharedOptions = this.getSharedOptions(firstOpts);\n const includeOptions = this.includeOptions(mode, sharedOptions);\n let startAngle = this._getRotation();\n let i;\n for (i = 0; i < start; ++i) {\n startAngle += this._circumference(i, reset);\n }\n for (i = start; i < start + count; ++i) {\n const circumference = this._circumference(i, reset);\n const arc = arcs[i];\n const properties = {\n x: centerX + this.offsetX,\n y: centerY + this.offsetY,\n startAngle,\n endAngle: startAngle + circumference,\n circumference,\n outerRadius,\n innerRadius\n };\n if (includeOptions) {\n properties.options = sharedOptions || this.resolveDataElementOptions(i, arc.active ? 'active' : mode);\n }\n startAngle += circumference;\n this.updateElement(arc, i, properties, mode);\n }\n this.updateSharedOptions(sharedOptions, mode, firstOpts);\n }\n calculateTotal() {\n const meta = this._cachedMeta;\n const metaData = meta.data;\n let total = 0;\n let i;\n for (i = 0; i < metaData.length; i++) {\n const value = meta._parsed[i];\n if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i) && !metaData[i].hidden) {\n total += Math.abs(value);\n }\n }\n return total;\n }\n calculateCircumference(value) {\n const total = this._cachedMeta.total;\n if (total > 0 && !isNaN(value)) {\n return TAU * (Math.abs(value) / total);\n }\n return 0;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const chart = this.chart;\n const labels = chart.data.labels || [];\n const value = formatNumber(meta._parsed[index], chart.options.locale);\n return {\n label: labels[index] || '',\n value,\n };\n }\n getMaxBorderWidth(arcs) {\n let max = 0;\n const chart = this.chart;\n let i, ilen, meta, controller, options;\n if (!arcs) {\n for (i = 0, ilen = chart.data.datasets.length; i < ilen; ++i) {\n if (chart.isDatasetVisible(i)) {\n meta = chart.getDatasetMeta(i);\n arcs = meta.data;\n controller = meta.controller;\n break;\n }\n }\n }\n if (!arcs) {\n return 0;\n }\n for (i = 0, ilen = arcs.length; i < ilen; ++i) {\n options = controller.resolveDataElementOptions(i);\n if (options.borderAlign !== 'inner') {\n max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0);\n }\n }\n return max;\n }\n getMaxOffset(arcs) {\n let max = 0;\n for (let i = 0, ilen = arcs.length; i < ilen; ++i) {\n const options = this.resolveDataElementOptions(i);\n max = Math.max(max, options.offset || 0, options.hoverOffset || 0);\n }\n return max;\n }\n _getRingWeightOffset(datasetIndex) {\n let ringWeightOffset = 0;\n for (let i = 0; i < datasetIndex; ++i) {\n if (this.chart.isDatasetVisible(i)) {\n ringWeightOffset += this._getRingWeight(i);\n }\n }\n return ringWeightOffset;\n }\n _getRingWeight(datasetIndex) {\n return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0);\n }\n _getVisibleDatasetWeightTotal() {\n return this._getRingWeightOffset(this.chart.data.datasets.length) || 1;\n }\n}\nDoughnutController.id = 'doughnut';\nDoughnutController.defaults = {\n datasetElementType: false,\n dataElementType: 'arc',\n animation: {\n animateRotate: true,\n animateScale: false\n },\n animations: {\n numbers: {\n type: 'number',\n properties: ['circumference', 'endAngle', 'innerRadius', 'outerRadius', 'startAngle', 'x', 'y', 'offset', 'borderWidth', 'spacing']\n },\n },\n cutout: '50%',\n rotation: 0,\n circumference: 360,\n radius: '100%',\n spacing: 0,\n indexAxis: 'r',\n};\nDoughnutController.descriptors = {\n _scriptable: (name) => name !== 'spacing',\n _indexable: (name) => name !== 'spacing',\n};\nDoughnutController.overrides = {\n aspectRatio: 1,\n plugins: {\n legend: {\n labels: {\n generateLabels(chart) {\n const data = chart.data;\n if (data.labels.length && data.datasets.length) {\n const {labels: {pointStyle}} = chart.legend.options;\n return data.labels.map((label, i) => {\n const meta = chart.getDatasetMeta(0);\n const style = meta.controller.getStyle(i);\n return {\n text: label,\n fillStyle: style.backgroundColor,\n strokeStyle: style.borderColor,\n lineWidth: style.borderWidth,\n pointStyle: pointStyle,\n hidden: !chart.getDataVisibility(i),\n index: i\n };\n });\n }\n return [];\n }\n },\n onClick(e, legendItem, legend) {\n legend.chart.toggleDataVisibility(legendItem.index);\n legend.chart.update();\n }\n },\n tooltip: {\n callbacks: {\n title() {\n return '';\n },\n label(tooltipItem) {\n let dataLabel = tooltipItem.label;\n const value = ': ' + tooltipItem.formattedValue;\n if (isArray(dataLabel)) {\n dataLabel = dataLabel.slice();\n dataLabel[0] += value;\n } else {\n dataLabel += value;\n }\n return dataLabel;\n }\n }\n }\n }\n};\n\nclass LineController extends DatasetController {\n initialize() {\n this.enableOptionSharing = true;\n this.supportsDecimation = true;\n super.initialize();\n }\n update(mode) {\n const meta = this._cachedMeta;\n const {dataset: line, data: points = [], _dataset} = meta;\n const animationsDisabled = this.chart._animationsDisabled;\n let {start, count} = getStartAndCountOfVisiblePoints(meta, points, animationsDisabled);\n this._drawStart = start;\n this._drawCount = count;\n if (scaleRangesChanged(meta)) {\n start = 0;\n count = points.length;\n }\n line._chart = this.chart;\n line._datasetIndex = this.index;\n line._decimated = !!_dataset._decimated;\n line.points = points;\n const options = this.resolveDatasetElementOptions(mode);\n if (!this.options.showLine) {\n options.borderWidth = 0;\n }\n options.segment = this.options.segment;\n this.updateElement(line, undefined, {\n animated: !animationsDisabled,\n options\n }, mode);\n this.updateElements(points, start, count, mode);\n }\n updateElements(points, start, count, mode) {\n const reset = mode === 'reset';\n const {iScale, vScale, _stacked, _dataset} = this._cachedMeta;\n const firstOpts = this.resolveDataElementOptions(start, mode);\n const sharedOptions = this.getSharedOptions(firstOpts);\n const includeOptions = this.includeOptions(mode, sharedOptions);\n const iAxis = iScale.axis;\n const vAxis = vScale.axis;\n const {spanGaps, segment} = this.options;\n const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY;\n const directUpdate = this.chart._animationsDisabled || reset || mode === 'none';\n let prevParsed = start > 0 && this.getParsed(start - 1);\n for (let i = start; i < start + count; ++i) {\n const point = points[i];\n const parsed = this.getParsed(i);\n const properties = directUpdate ? point : {};\n const nullData = isNullOrUndef(parsed[vAxis]);\n const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i);\n const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i);\n properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData;\n properties.stop = i > 0 && (Math.abs(parsed[iAxis] - prevParsed[iAxis])) > maxGapLength;\n if (segment) {\n properties.parsed = parsed;\n properties.raw = _dataset.data[i];\n }\n if (includeOptions) {\n properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode);\n }\n if (!directUpdate) {\n this.updateElement(point, i, properties, mode);\n }\n prevParsed = parsed;\n }\n this.updateSharedOptions(sharedOptions, mode, firstOpts);\n }\n getMaxOverflow() {\n const meta = this._cachedMeta;\n const dataset = meta.dataset;\n const border = dataset.options && dataset.options.borderWidth || 0;\n const data = meta.data || [];\n if (!data.length) {\n return border;\n }\n const firstPoint = data[0].size(this.resolveDataElementOptions(0));\n const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1));\n return Math.max(border, firstPoint, lastPoint) / 2;\n }\n draw() {\n const meta = this._cachedMeta;\n meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis);\n super.draw();\n }\n}\nLineController.id = 'line';\nLineController.defaults = {\n datasetElementType: 'line',\n dataElementType: 'point',\n showLine: true,\n spanGaps: false,\n};\nLineController.overrides = {\n scales: {\n _index_: {\n type: 'category',\n },\n _value_: {\n type: 'linear',\n },\n }\n};\nfunction getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) {\n const pointCount = points.length;\n let start = 0;\n let count = pointCount;\n if (meta._sorted) {\n const {iScale, _parsed} = meta;\n const axis = iScale.axis;\n const {min, max, minDefined, maxDefined} = iScale.getUserBounds();\n if (minDefined) {\n start = _limitValue(Math.min(\n _lookupByKey(_parsed, iScale.axis, min).lo,\n animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo),\n 0, pointCount - 1);\n }\n if (maxDefined) {\n count = _limitValue(Math.max(\n _lookupByKey(_parsed, iScale.axis, max).hi + 1,\n animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max)).hi + 1),\n start, pointCount) - start;\n } else {\n count = pointCount - start;\n }\n }\n return {start, count};\n}\nfunction scaleRangesChanged(meta) {\n const {xScale, yScale, _scaleRanges} = meta;\n const newRanges = {\n xmin: xScale.min,\n xmax: xScale.max,\n ymin: yScale.min,\n ymax: yScale.max\n };\n if (!_scaleRanges) {\n meta._scaleRanges = newRanges;\n return true;\n }\n const changed = _scaleRanges.xmin !== xScale.min\n\t\t|| _scaleRanges.xmax !== xScale.max\n\t\t|| _scaleRanges.ymin !== yScale.min\n\t\t|| _scaleRanges.ymax !== yScale.max;\n Object.assign(_scaleRanges, newRanges);\n return changed;\n}\n\nclass PolarAreaController extends DatasetController {\n constructor(chart, datasetIndex) {\n super(chart, datasetIndex);\n this.innerRadius = undefined;\n this.outerRadius = undefined;\n }\n getLabelAndValue(index) {\n const meta = this._cachedMeta;\n const chart = this.chart;\n const labels = chart.data.labels || [];\n const value = formatNumber(meta._parsed[index].r, chart.options.locale);\n return {\n label: labels[index] || '',\n value,\n };\n }\n parseObjectData(meta, data, start, count) {\n return _parseObjectDataRadialScale.bind(this)(meta, data, start, count);\n }\n update(mode) {\n const arcs = this._cachedMeta.data;\n this._updateRadius();\n this.updateElements(arcs, 0, arcs.length, mode);\n }\n getMinMax() {\n const meta = this._cachedMeta;\n const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY};\n meta.data.forEach((element, index) => {\n const parsed = this.getParsed(index).r;\n if (!isNaN(parsed) && this.chart.getDataVisibility(index)) {\n if (parsed < range.min) {\n range.min = parsed;\n }\n if (parsed > range.max) {\n range.max = parsed;\n }\n }\n });\n return range;\n }\n _updateRadius() {\n const chart = this.chart;\n const chartArea = chart.chartArea;\n const opts = chart.options;\n const minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);\n const outerRadius = Math.max(minSize / 2, 0);\n const innerRadius = Math.max(opts.cutoutPercentage ? (outerRadius / 100) * (opts.cutoutPercentage) : 1, 0);\n const radiusLength = (outerRadius - innerRadius) / chart.getVisibleDatasetCount();\n this.outerRadius = outerRadius - (radiusLength * this.index);\n this.innerRadius = this.outerRadius - radiusLength;\n }\n updateElements(arcs, start, count, mode) {\n const reset = mode === 'reset';\n const chart = this.chart;\n const opts = chart.options;\n const animationOpts = opts.animation;\n const scale = this._cachedMeta.rScale;\n const centerX = scale.xCenter;\n const centerY = scale.yCenter;\n const datasetStartAngle = scale.getIndexAngle(0) - 0.5 * PI;\n let angle = datasetStartAngle;\n let i;\n const defaultAngle = 360 / this.countVisibleElements();\n for (i = 0; i < start; ++i) {\n angle += this._computeAngle(i, mode, defaultAngle);\n }\n for (i = start; i < start + count; i++) {\n const arc = arcs[i];\n let startAngle = angle;\n let endAngle = angle + this._computeAngle(i, mode, defaultAngle);\n let outerRadius = chart.getDataVisibility(i) ? scale.getDistanceFromCenterForValue(this.getParsed(i).r) : 0;\n angle = endAngle;\n if (reset) {\n if (animationOpts.animateScale) {\n outerRadius = 0;\n }\n if (animationOpts.animateRotate) {\n startAngle = endAngle = datasetStartAngle;\n }\n }\n const properties = {\n x: centerX,\n y: centerY,\n innerRadius: 0,\n outerRadius,\n startAngle,\n endAngle,\n options: this.resolveDataElementOptions(i, arc.active ? 'active' : mode)\n };\n this.updateElement(arc, i, properties, mode);\n }\n }\n countVisibleElements() {\n const meta = this._cachedMeta;\n let count = 0;\n meta.data.forEach((element, index) => {\n if (!isNaN(this.getParsed(index).r) && this.chart.getDataVisibility(index)) {\n count++;\n }\n });\n return count;\n }\n _computeAngle(index, mode, defaultAngle) {\n return this.chart.getDataVisibility(index)\n ? toRadians(this.resolveDataElementOptions(index, mode).angle || defaultAngle)\n : 0;\n }\n}\nPolarAreaController.id = 'polarArea';\nPolarAreaController.defaults = {\n dataElementType: 'arc',\n animation: {\n animateRotate: true,\n animateScale: true\n },\n animations: {\n numbers: {\n type: 'number',\n properties: ['x', 'y', 'startAngle', 'endAngle', 'innerRadius', 'outerRadius']\n },\n },\n indexAxis: 'r',\n startAngle: 0,\n};\nPolarAreaController.overrides = {\n aspectRatio: 1,\n plugins: {\n legend: {\n labels: {\n generateLabels(chart) {\n const data = chart.data;\n if (data.labels.length && data.datasets.length) {\n const {labels: {pointStyle}} = chart.legend.options;\n return data.labels.map((label, i) => {\n const meta = chart.getDatasetMeta(0);\n const style = meta.controller.getStyle(i);\n return {\n text: label,\n fillStyle: style.backgroundColor,\n strokeStyle: style.borderColor,\n lineWidth: style.borderWidth,\n pointStyle: pointStyle,\n hidden: !chart.getDataVisibility(i),\n index: i\n };\n });\n }\n return [];\n }\n },\n onClick(e, legendItem, legend) {\n legend.chart.toggleDataVisibility(legendItem.index);\n legend.chart.update();\n }\n },\n tooltip: {\n callbacks: {\n title() {\n return '';\n },\n label(context) {\n return context.chart.data.labels[context.dataIndex] + ': ' + context.formattedValue;\n }\n }\n }\n },\n scales: {\n r: {\n type: 'radialLinear',\n angleLines: {\n display: false\n },\n beginAtZero: true,\n grid: {\n circular: true\n },\n pointLabels: {\n display: false\n },\n startAngle: 0\n }\n }\n};\n\nclass PieController extends DoughnutController {\n}\nPieController.id = 'pie';\nPieController.defaults = {\n cutout: 0,\n rotation: 0,\n circumference: 360,\n radius: '100%'\n};\n\nclass RadarController extends DatasetController {\n getLabelAndValue(index) {\n const vScale = this._cachedMeta.vScale;\n const parsed = this.getParsed(index);\n return {\n label: vScale.getLabels()[index],\n value: '' + vScale.getLabelForValue(parsed[vScale.axis])\n };\n }\n parseObjectData(meta, data, start, count) {\n return _parseObjectDataRadialScale.bind(this)(meta, data, start, count);\n }\n update(mode) {\n const meta = this._cachedMeta;\n const line = meta.dataset;\n const points = meta.data || [];\n const labels = meta.iScale.getLabels();\n line.points = points;\n if (mode !== 'resize') {\n const options = this.resolveDatasetElementOptions(mode);\n if (!this.options.showLine) {\n options.borderWidth = 0;\n }\n const properties = {\n _loop: true,\n _fullLoop: labels.length === points.length,\n options\n };\n this.updateElement(line, undefined, properties, mode);\n }\n this.updateElements(points, 0, points.length, mode);\n }\n updateElements(points, start, count, mode) {\n const scale = this._cachedMeta.rScale;\n const reset = mode === 'reset';\n for (let i = start; i < start + count; i++) {\n const point = points[i];\n const options = this.resolveDataElementOptions(i, point.active ? 'active' : mode);\n const pointPosition = scale.getPointPositionForValue(i, this.getParsed(i).r);\n const x = reset ? scale.xCenter : pointPosition.x;\n const y = reset ? scale.yCenter : pointPosition.y;\n const properties = {\n x,\n y,\n angle: pointPosition.angle,\n skip: isNaN(x) || isNaN(y),\n options\n };\n this.updateElement(point, i, properties, mode);\n }\n }\n}\nRadarController.id = 'radar';\nRadarController.defaults = {\n datasetElementType: 'line',\n dataElementType: 'point',\n indexAxis: 'r',\n showLine: true,\n elements: {\n line: {\n fill: 'start'\n }\n },\n};\nRadarController.overrides = {\n aspectRatio: 1,\n scales: {\n r: {\n type: 'radialLinear',\n }\n }\n};\n\nclass ScatterController extends LineController {\n}\nScatterController.id = 'scatter';\nScatterController.defaults = {\n showLine: false,\n fill: false\n};\nScatterController.overrides = {\n interaction: {\n mode: 'point'\n },\n plugins: {\n tooltip: {\n callbacks: {\n title() {\n return '';\n },\n label(item) {\n return '(' + item.label + ', ' + item.formattedValue + ')';\n }\n }\n }\n },\n scales: {\n x: {\n type: 'linear'\n },\n y: {\n type: 'linear'\n }\n }\n};\n\nvar controllers = /*#__PURE__*/Object.freeze({\n__proto__: null,\nBarController: BarController,\nBubbleController: BubbleController,\nDoughnutController: DoughnutController,\nLineController: LineController,\nPolarAreaController: PolarAreaController,\nPieController: PieController,\nRadarController: RadarController,\nScatterController: ScatterController\n});\n\nfunction abstract() {\n throw new Error('This method is not implemented: Check that a complete date adapter is provided.');\n}\nclass DateAdapter {\n constructor(options) {\n this.options = options || {};\n }\n formats() {\n return abstract();\n }\n parse(value, format) {\n return abstract();\n }\n format(timestamp, format) {\n return abstract();\n }\n add(timestamp, amount, unit) {\n return abstract();\n }\n diff(a, b, unit) {\n return abstract();\n }\n startOf(timestamp, unit, weekday) {\n return abstract();\n }\n endOf(timestamp, unit) {\n return abstract();\n }\n}\nDateAdapter.override = function(members) {\n Object.assign(DateAdapter.prototype, members);\n};\nvar adapters = {\n _date: DateAdapter\n};\n\nfunction binarySearch(metaset, axis, value, intersect) {\n const {controller, data, _sorted} = metaset;\n const iScale = controller._cachedMeta.iScale;\n if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) {\n const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;\n if (!intersect) {\n return lookupMethod(data, axis, value);\n } else if (controller._sharedOptions) {\n const el = data[0];\n const range = typeof el.getRange === 'function' && el.getRange(axis);\n if (range) {\n const start = lookupMethod(data, axis, value - range);\n const end = lookupMethod(data, axis, value + range);\n return {lo: start.lo, hi: end.hi};\n }\n }\n }\n return {lo: 0, hi: data.length - 1};\n}\nfunction evaluateInteractionItems(chart, axis, position, handler, intersect) {\n const metasets = chart.getSortedVisibleDatasetMetas();\n const value = position[axis];\n for (let i = 0, ilen = metasets.length; i < ilen; ++i) {\n const {index, data} = metasets[i];\n const {lo, hi} = binarySearch(metasets[i], axis, value, intersect);\n for (let j = lo; j <= hi; ++j) {\n const element = data[j];\n if (!element.skip) {\n handler(element, index, j);\n }\n }\n }\n}\nfunction getDistanceMetricForAxis(axis) {\n const useX = axis.indexOf('x') !== -1;\n const useY = axis.indexOf('y') !== -1;\n return function(pt1, pt2) {\n const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0;\n const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0;\n return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));\n };\n}\nfunction getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) {\n const items = [];\n if (!includeInvisible && !chart.isPointInArea(position)) {\n return items;\n }\n const evaluationFunc = function(element, datasetIndex, index) {\n if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) {\n return;\n }\n if (element.inRange(position.x, position.y, useFinalPosition)) {\n items.push({element, datasetIndex, index});\n }\n };\n evaluateInteractionItems(chart, axis, position, evaluationFunc, true);\n return items;\n}\nfunction getNearestRadialItems(chart, position, axis, useFinalPosition) {\n let items = [];\n function evaluationFunc(element, datasetIndex, index) {\n const {startAngle, endAngle} = element.getProps(['startAngle', 'endAngle'], useFinalPosition);\n const {angle} = getAngleFromPoint(element, {x: position.x, y: position.y});\n if (_angleBetween(angle, startAngle, endAngle)) {\n items.push({element, datasetIndex, index});\n }\n }\n evaluateInteractionItems(chart, axis, position, evaluationFunc);\n return items;\n}\nfunction getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {\n let items = [];\n const distanceMetric = getDistanceMetricForAxis(axis);\n let minDistance = Number.POSITIVE_INFINITY;\n function evaluationFunc(element, datasetIndex, index) {\n const inRange = element.inRange(position.x, position.y, useFinalPosition);\n if (intersect && !inRange) {\n return;\n }\n const center = element.getCenterPoint(useFinalPosition);\n const pointInArea = !!includeInvisible || chart.isPointInArea(center);\n if (!pointInArea && !inRange) {\n return;\n }\n const distance = distanceMetric(position, center);\n if (distance < minDistance) {\n items = [{element, datasetIndex, index}];\n minDistance = distance;\n } else if (distance === minDistance) {\n items.push({element, datasetIndex, index});\n }\n }\n evaluateInteractionItems(chart, axis, position, evaluationFunc);\n return items;\n}\nfunction getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) {\n if (!includeInvisible && !chart.isPointInArea(position)) {\n return [];\n }\n return axis === 'r' && !intersect\n ? getNearestRadialItems(chart, position, axis, useFinalPosition)\n : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible);\n}\nfunction getAxisItems(chart, position, axis, intersect, useFinalPosition) {\n const items = [];\n const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange';\n let intersectsItem = false;\n evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index) => {\n if (element[rangeMethod](position[axis], useFinalPosition)) {\n items.push({element, datasetIndex, index});\n intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition);\n }\n });\n if (intersect && !intersectsItem) {\n return [];\n }\n return items;\n}\nvar Interaction = {\n evaluateInteractionItems,\n modes: {\n index(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n const axis = options.axis || 'x';\n const includeInvisible = options.includeInvisible || false;\n const items = options.intersect\n ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible)\n : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);\n const elements = [];\n if (!items.length) {\n return [];\n }\n chart.getSortedVisibleDatasetMetas().forEach((meta) => {\n const index = items[0].index;\n const element = meta.data[index];\n if (element && !element.skip) {\n elements.push({element, datasetIndex: meta.index, index});\n }\n });\n return elements;\n },\n dataset(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n const axis = options.axis || 'xy';\n const includeInvisible = options.includeInvisible || false;\n let items = options.intersect\n ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) :\n getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible);\n if (items.length > 0) {\n const datasetIndex = items[0].datasetIndex;\n const data = chart.getDatasetMeta(datasetIndex).data;\n items = [];\n for (let i = 0; i < data.length; ++i) {\n items.push({element: data[i], datasetIndex, index: i});\n }\n }\n return items;\n },\n point(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n const axis = options.axis || 'xy';\n const includeInvisible = options.includeInvisible || false;\n return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible);\n },\n nearest(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n const axis = options.axis || 'xy';\n const includeInvisible = options.includeInvisible || false;\n return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible);\n },\n x(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n return getAxisItems(chart, position, 'x', options.intersect, useFinalPosition);\n },\n y(chart, e, options, useFinalPosition) {\n const position = getRelativePosition(e, chart);\n return getAxisItems(chart, position, 'y', options.intersect, useFinalPosition);\n }\n }\n};\n\nconst STATIC_POSITIONS = ['left', 'top', 'right', 'bottom'];\nfunction filterByPosition(array, position) {\n return array.filter(v => v.pos === position);\n}\nfunction filterDynamicPositionByAxis(array, axis) {\n return array.filter(v => STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis);\n}\nfunction sortByWeight(array, reverse) {\n return array.sort((a, b) => {\n const v0 = reverse ? b : a;\n const v1 = reverse ? a : b;\n return v0.weight === v1.weight ?\n v0.index - v1.index :\n v0.weight - v1.weight;\n });\n}\nfunction wrapBoxes(boxes) {\n const layoutBoxes = [];\n let i, ilen, box, pos, stack, stackWeight;\n for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) {\n box = boxes[i];\n ({position: pos, options: {stack, stackWeight = 1}} = box);\n layoutBoxes.push({\n index: i,\n box,\n pos,\n horizontal: box.isHorizontal(),\n weight: box.weight,\n stack: stack && (pos + stack),\n stackWeight\n });\n }\n return layoutBoxes;\n}\nfunction buildStacks(layouts) {\n const stacks = {};\n for (const wrap of layouts) {\n const {stack, pos, stackWeight} = wrap;\n if (!stack || !STATIC_POSITIONS.includes(pos)) {\n continue;\n }\n const _stack = stacks[stack] || (stacks[stack] = {count: 0, placed: 0, weight: 0, size: 0});\n _stack.count++;\n _stack.weight += stackWeight;\n }\n return stacks;\n}\nfunction setLayoutDims(layouts, params) {\n const stacks = buildStacks(layouts);\n const {vBoxMaxWidth, hBoxMaxHeight} = params;\n let i, ilen, layout;\n for (i = 0, ilen = layouts.length; i < ilen; ++i) {\n layout = layouts[i];\n const {fullSize} = layout.box;\n const stack = stacks[layout.stack];\n const factor = stack && layout.stackWeight / stack.weight;\n if (layout.horizontal) {\n layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth;\n layout.height = hBoxMaxHeight;\n } else {\n layout.width = vBoxMaxWidth;\n layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight;\n }\n }\n return stacks;\n}\nfunction buildLayoutBoxes(boxes) {\n const layoutBoxes = wrapBoxes(boxes);\n const fullSize = sortByWeight(layoutBoxes.filter(wrap => wrap.box.fullSize), true);\n const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true);\n const right = sortByWeight(filterByPosition(layoutBoxes, 'right'));\n const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true);\n const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom'));\n const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x');\n const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y');\n return {\n fullSize,\n leftAndTop: left.concat(top),\n rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal),\n chartArea: filterByPosition(layoutBoxes, 'chartArea'),\n vertical: left.concat(right).concat(centerVertical),\n horizontal: top.concat(bottom).concat(centerHorizontal)\n };\n}\nfunction getCombinedMax(maxPadding, chartArea, a, b) {\n return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]);\n}\nfunction updateMaxPadding(maxPadding, boxPadding) {\n maxPadding.top = Math.max(maxPadding.top, boxPadding.top);\n maxPadding.left = Math.max(maxPadding.left, boxPadding.left);\n maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom);\n maxPadding.right = Math.max(maxPadding.right, boxPadding.right);\n}\nfunction updateDims(chartArea, params, layout, stacks) {\n const {pos, box} = layout;\n const maxPadding = chartArea.maxPadding;\n if (!isObject(pos)) {\n if (layout.size) {\n chartArea[pos] -= layout.size;\n }\n const stack = stacks[layout.stack] || {size: 0, count: 1};\n stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width);\n layout.size = stack.size / stack.count;\n chartArea[pos] += layout.size;\n }\n if (box.getPadding) {\n updateMaxPadding(maxPadding, box.getPadding());\n }\n const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right'));\n const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom'));\n const widthChanged = newWidth !== chartArea.w;\n const heightChanged = newHeight !== chartArea.h;\n chartArea.w = newWidth;\n chartArea.h = newHeight;\n return layout.horizontal\n ? {same: widthChanged, other: heightChanged}\n : {same: heightChanged, other: widthChanged};\n}\nfunction handleMaxPadding(chartArea) {\n const maxPadding = chartArea.maxPadding;\n function updatePos(pos) {\n const change = Math.max(maxPadding[pos] - chartArea[pos], 0);\n chartArea[pos] += change;\n return change;\n }\n chartArea.y += updatePos('top');\n chartArea.x += updatePos('left');\n updatePos('right');\n updatePos('bottom');\n}\nfunction getMargins(horizontal, chartArea) {\n const maxPadding = chartArea.maxPadding;\n function marginForPositions(positions) {\n const margin = {left: 0, top: 0, right: 0, bottom: 0};\n positions.forEach((pos) => {\n margin[pos] = Math.max(chartArea[pos], maxPadding[pos]);\n });\n return margin;\n }\n return horizontal\n ? marginForPositions(['left', 'right'])\n : marginForPositions(['top', 'bottom']);\n}\nfunction fitBoxes(boxes, chartArea, params, stacks) {\n const refitBoxes = [];\n let i, ilen, layout, box, refit, changed;\n for (i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i) {\n layout = boxes[i];\n box = layout.box;\n box.update(\n layout.width || chartArea.w,\n layout.height || chartArea.h,\n getMargins(layout.horizontal, chartArea)\n );\n const {same, other} = updateDims(chartArea, params, layout, stacks);\n refit |= same && refitBoxes.length;\n changed = changed || other;\n if (!box.fullSize) {\n refitBoxes.push(layout);\n }\n }\n return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed;\n}\nfunction setBoxDims(box, left, top, width, height) {\n box.top = top;\n box.left = left;\n box.right = left + width;\n box.bottom = top + height;\n box.width = width;\n box.height = height;\n}\nfunction placeBoxes(boxes, chartArea, params, stacks) {\n const userPadding = params.padding;\n let {x, y} = chartArea;\n for (const layout of boxes) {\n const box = layout.box;\n const stack = stacks[layout.stack] || {count: 1, placed: 0, weight: 1};\n const weight = (layout.stackWeight / stack.weight) || 1;\n if (layout.horizontal) {\n const width = chartArea.w * weight;\n const height = stack.size || box.height;\n if (defined(stack.start)) {\n y = stack.start;\n }\n if (box.fullSize) {\n setBoxDims(box, userPadding.left, y, params.outerWidth - userPadding.right - userPadding.left, height);\n } else {\n setBoxDims(box, chartArea.left + stack.placed, y, width, height);\n }\n stack.start = y;\n stack.placed += width;\n y = box.bottom;\n } else {\n const height = chartArea.h * weight;\n const width = stack.size || box.width;\n if (defined(stack.start)) {\n x = stack.start;\n }\n if (box.fullSize) {\n setBoxDims(box, x, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top);\n } else {\n setBoxDims(box, x, chartArea.top + stack.placed, width, height);\n }\n stack.start = x;\n stack.placed += height;\n x = box.right;\n }\n }\n chartArea.x = x;\n chartArea.y = y;\n}\ndefaults.set('layout', {\n autoPadding: true,\n padding: {\n top: 0,\n right: 0,\n bottom: 0,\n left: 0\n }\n});\nvar layouts = {\n addBox(chart, item) {\n if (!chart.boxes) {\n chart.boxes = [];\n }\n item.fullSize = item.fullSize || false;\n item.position = item.position || 'top';\n item.weight = item.weight || 0;\n item._layers = item._layers || function() {\n return [{\n z: 0,\n draw(chartArea) {\n item.draw(chartArea);\n }\n }];\n };\n chart.boxes.push(item);\n },\n removeBox(chart, layoutItem) {\n const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1;\n if (index !== -1) {\n chart.boxes.splice(index, 1);\n }\n },\n configure(chart, item, options) {\n item.fullSize = options.fullSize;\n item.position = options.position;\n item.weight = options.weight;\n },\n update(chart, width, height, minPadding) {\n if (!chart) {\n return;\n }\n const padding = toPadding(chart.options.layout.padding);\n const availableWidth = Math.max(width - padding.width, 0);\n const availableHeight = Math.max(height - padding.height, 0);\n const boxes = buildLayoutBoxes(chart.boxes);\n const verticalBoxes = boxes.vertical;\n const horizontalBoxes = boxes.horizontal;\n each(chart.boxes, box => {\n if (typeof box.beforeLayout === 'function') {\n box.beforeLayout();\n }\n });\n const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) =>\n wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1;\n const params = Object.freeze({\n outerWidth: width,\n outerHeight: height,\n padding,\n availableWidth,\n availableHeight,\n vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount,\n hBoxMaxHeight: availableHeight / 2\n });\n const maxPadding = Object.assign({}, padding);\n updateMaxPadding(maxPadding, toPadding(minPadding));\n const chartArea = Object.assign({\n maxPadding,\n w: availableWidth,\n h: availableHeight,\n x: padding.left,\n y: padding.top\n }, padding);\n const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params);\n fitBoxes(boxes.fullSize, chartArea, params, stacks);\n fitBoxes(verticalBoxes, chartArea, params, stacks);\n if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) {\n fitBoxes(verticalBoxes, chartArea, params, stacks);\n }\n handleMaxPadding(chartArea);\n placeBoxes(boxes.leftAndTop, chartArea, params, stacks);\n chartArea.x += chartArea.w;\n chartArea.y += chartArea.h;\n placeBoxes(boxes.rightAndBottom, chartArea, params, stacks);\n chart.chartArea = {\n left: chartArea.left,\n top: chartArea.top,\n right: chartArea.left + chartArea.w,\n bottom: chartArea.top + chartArea.h,\n height: chartArea.h,\n width: chartArea.w,\n };\n each(boxes.chartArea, (layout) => {\n const box = layout.box;\n Object.assign(box, chart.chartArea);\n box.update(chartArea.w, chartArea.h, {left: 0, top: 0, right: 0, bottom: 0});\n });\n }\n};\n\nclass BasePlatform {\n acquireContext(canvas, aspectRatio) {}\n releaseContext(context) {\n return false;\n }\n addEventListener(chart, type, listener) {}\n removeEventListener(chart, type, listener) {}\n getDevicePixelRatio() {\n return 1;\n }\n getMaximumSize(element, width, height, aspectRatio) {\n width = Math.max(0, width || element.width);\n height = height || element.height;\n return {\n width,\n height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height)\n };\n }\n isAttached(canvas) {\n return true;\n }\n updateConfig(config) {\n }\n}\n\nclass BasicPlatform extends BasePlatform {\n acquireContext(item) {\n return item && item.getContext && item.getContext('2d') || null;\n }\n updateConfig(config) {\n config.options.animation = false;\n }\n}\n\nconst EXPANDO_KEY = '$chartjs';\nconst EVENT_TYPES = {\n touchstart: 'mousedown',\n touchmove: 'mousemove',\n touchend: 'mouseup',\n pointerenter: 'mouseenter',\n pointerdown: 'mousedown',\n pointermove: 'mousemove',\n pointerup: 'mouseup',\n pointerleave: 'mouseout',\n pointerout: 'mouseout'\n};\nconst isNullOrEmpty = value => value === null || value === '';\nfunction initCanvas(canvas, aspectRatio) {\n const style = canvas.style;\n const renderHeight = canvas.getAttribute('height');\n const renderWidth = canvas.getAttribute('width');\n canvas[EXPANDO_KEY] = {\n initial: {\n height: renderHeight,\n width: renderWidth,\n style: {\n display: style.display,\n height: style.height,\n width: style.width\n }\n }\n };\n style.display = style.display || 'block';\n style.boxSizing = style.boxSizing || 'border-box';\n if (isNullOrEmpty(renderWidth)) {\n const displayWidth = readUsedSize(canvas, 'width');\n if (displayWidth !== undefined) {\n canvas.width = displayWidth;\n }\n }\n if (isNullOrEmpty(renderHeight)) {\n if (canvas.style.height === '') {\n canvas.height = canvas.width / (aspectRatio || 2);\n } else {\n const displayHeight = readUsedSize(canvas, 'height');\n if (displayHeight !== undefined) {\n canvas.height = displayHeight;\n }\n }\n }\n return canvas;\n}\nconst eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false;\nfunction addListener(node, type, listener) {\n node.addEventListener(type, listener, eventListenerOptions);\n}\nfunction removeListener(chart, type, listener) {\n chart.canvas.removeEventListener(type, listener, eventListenerOptions);\n}\nfunction fromNativeEvent(event, chart) {\n const type = EVENT_TYPES[event.type] || event.type;\n const {x, y} = getRelativePosition(event, chart);\n return {\n type,\n chart,\n native: event,\n x: x !== undefined ? x : null,\n y: y !== undefined ? y : null,\n };\n}\nfunction nodeListContains(nodeList, canvas) {\n for (const node of nodeList) {\n if (node === canvas || node.contains(canvas)) {\n return true;\n }\n }\n}\nfunction createAttachObserver(chart, type, listener) {\n const canvas = chart.canvas;\n const observer = new MutationObserver(entries => {\n let trigger = false;\n for (const entry of entries) {\n trigger = trigger || nodeListContains(entry.addedNodes, canvas);\n trigger = trigger && !nodeListContains(entry.removedNodes, canvas);\n }\n if (trigger) {\n listener();\n }\n });\n observer.observe(document, {childList: true, subtree: true});\n return observer;\n}\nfunction createDetachObserver(chart, type, listener) {\n const canvas = chart.canvas;\n const observer = new MutationObserver(entries => {\n let trigger = false;\n for (const entry of entries) {\n trigger = trigger || nodeListContains(entry.removedNodes, canvas);\n trigger = trigger && !nodeListContains(entry.addedNodes, canvas);\n }\n if (trigger) {\n listener();\n }\n });\n observer.observe(document, {childList: true, subtree: true});\n return observer;\n}\nconst drpListeningCharts = new Map();\nlet oldDevicePixelRatio = 0;\nfunction onWindowResize() {\n const dpr = window.devicePixelRatio;\n if (dpr === oldDevicePixelRatio) {\n return;\n }\n oldDevicePixelRatio = dpr;\n drpListeningCharts.forEach((resize, chart) => {\n if (chart.currentDevicePixelRatio !== dpr) {\n resize();\n }\n });\n}\nfunction listenDevicePixelRatioChanges(chart, resize) {\n if (!drpListeningCharts.size) {\n window.addEventListener('resize', onWindowResize);\n }\n drpListeningCharts.set(chart, resize);\n}\nfunction unlistenDevicePixelRatioChanges(chart) {\n drpListeningCharts.delete(chart);\n if (!drpListeningCharts.size) {\n window.removeEventListener('resize', onWindowResize);\n }\n}\nfunction createResizeObserver(chart, type, listener) {\n const canvas = chart.canvas;\n const container = canvas && _getParentNode(canvas);\n if (!container) {\n return;\n }\n const resize = throttled((width, height) => {\n const w = container.clientWidth;\n listener(width, height);\n if (w < container.clientWidth) {\n listener();\n }\n }, window);\n const observer = new ResizeObserver(entries => {\n const entry = entries[0];\n const width = entry.contentRect.width;\n const height = entry.contentRect.height;\n if (width === 0 && height === 0) {\n return;\n }\n resize(width, height);\n });\n observer.observe(container);\n listenDevicePixelRatioChanges(chart, resize);\n return observer;\n}\nfunction releaseObserver(chart, type, observer) {\n if (observer) {\n observer.disconnect();\n }\n if (type === 'resize') {\n unlistenDevicePixelRatioChanges(chart);\n }\n}\nfunction createProxyAndListen(chart, type, listener) {\n const canvas = chart.canvas;\n const proxy = throttled((event) => {\n if (chart.ctx !== null) {\n listener(fromNativeEvent(event, chart));\n }\n }, chart, (args) => {\n const event = args[0];\n return [event, event.offsetX, event.offsetY];\n });\n addListener(canvas, type, proxy);\n return proxy;\n}\nclass DomPlatform extends BasePlatform {\n acquireContext(canvas, aspectRatio) {\n const context = canvas && canvas.getContext && canvas.getContext('2d');\n if (context && context.canvas === canvas) {\n initCanvas(canvas, aspectRatio);\n return context;\n }\n return null;\n }\n releaseContext(context) {\n const canvas = context.canvas;\n if (!canvas[EXPANDO_KEY]) {\n return false;\n }\n const initial = canvas[EXPANDO_KEY].initial;\n ['height', 'width'].forEach((prop) => {\n const value = initial[prop];\n if (isNullOrUndef(value)) {\n canvas.removeAttribute(prop);\n } else {\n canvas.setAttribute(prop, value);\n }\n });\n const style = initial.style || {};\n Object.keys(style).forEach((key) => {\n canvas.style[key] = style[key];\n });\n canvas.width = canvas.width;\n delete canvas[EXPANDO_KEY];\n return true;\n }\n addEventListener(chart, type, listener) {\n this.removeEventListener(chart, type);\n const proxies = chart.$proxies || (chart.$proxies = {});\n const handlers = {\n attach: createAttachObserver,\n detach: createDetachObserver,\n resize: createResizeObserver\n };\n const handler = handlers[type] || createProxyAndListen;\n proxies[type] = handler(chart, type, listener);\n }\n removeEventListener(chart, type) {\n const proxies = chart.$proxies || (chart.$proxies = {});\n const proxy = proxies[type];\n if (!proxy) {\n return;\n }\n const handlers = {\n attach: releaseObserver,\n detach: releaseObserver,\n resize: releaseObserver\n };\n const handler = handlers[type] || removeListener;\n handler(chart, type, proxy);\n proxies[type] = undefined;\n }\n getDevicePixelRatio() {\n return window.devicePixelRatio;\n }\n getMaximumSize(canvas, width, height, aspectRatio) {\n return getMaximumSize(canvas, width, height, aspectRatio);\n }\n isAttached(canvas) {\n const container = _getParentNode(canvas);\n return !!(container && container.isConnected);\n }\n}\n\nfunction _detectPlatform(canvas) {\n if (!_isDomSupported() || (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas)) {\n return BasicPlatform;\n }\n return DomPlatform;\n}\n\nclass Element {\n constructor() {\n this.x = undefined;\n this.y = undefined;\n this.active = false;\n this.options = undefined;\n this.$animations = undefined;\n }\n tooltipPosition(useFinalPosition) {\n const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n return {x, y};\n }\n hasValue() {\n return isNumber(this.x) && isNumber(this.y);\n }\n getProps(props, final) {\n const anims = this.$animations;\n if (!final || !anims) {\n return this;\n }\n const ret = {};\n props.forEach(prop => {\n ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop];\n });\n return ret;\n }\n}\nElement.defaults = {};\nElement.defaultRoutes = undefined;\n\nconst formatters = {\n values(value) {\n return isArray(value) ? value : '' + value;\n },\n numeric(tickValue, index, ticks) {\n if (tickValue === 0) {\n return '0';\n }\n const locale = this.chart.options.locale;\n let notation;\n let delta = tickValue;\n if (ticks.length > 1) {\n const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));\n if (maxTick < 1e-4 || maxTick > 1e+15) {\n notation = 'scientific';\n }\n delta = calculateDelta(tickValue, ticks);\n }\n const logDelta = log10(Math.abs(delta));\n const numDecimal = Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);\n const options = {notation, minimumFractionDigits: numDecimal, maximumFractionDigits: numDecimal};\n Object.assign(options, this.options.ticks.format);\n return formatNumber(tickValue, locale, options);\n },\n logarithmic(tickValue, index, ticks) {\n if (tickValue === 0) {\n return '0';\n }\n const remain = tickValue / (Math.pow(10, Math.floor(log10(tickValue))));\n if (remain === 1 || remain === 2 || remain === 5) {\n return formatters.numeric.call(this, tickValue, index, ticks);\n }\n return '';\n }\n};\nfunction calculateDelta(tickValue, ticks) {\n let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;\n if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {\n delta = tickValue - Math.floor(tickValue);\n }\n return delta;\n}\nvar Ticks = {formatters};\n\ndefaults.set('scale', {\n display: true,\n offset: false,\n reverse: false,\n beginAtZero: false,\n bounds: 'ticks',\n grace: 0,\n grid: {\n display: true,\n lineWidth: 1,\n drawBorder: true,\n drawOnChartArea: true,\n drawTicks: true,\n tickLength: 8,\n tickWidth: (_ctx, options) => options.lineWidth,\n tickColor: (_ctx, options) => options.color,\n offset: false,\n borderDash: [],\n borderDashOffset: 0.0,\n borderWidth: 1\n },\n title: {\n display: false,\n text: '',\n padding: {\n top: 4,\n bottom: 4\n }\n },\n ticks: {\n minRotation: 0,\n maxRotation: 50,\n mirror: false,\n textStrokeWidth: 0,\n textStrokeColor: '',\n padding: 3,\n display: true,\n autoSkip: true,\n autoSkipPadding: 3,\n labelOffset: 0,\n callback: Ticks.formatters.values,\n minor: {},\n major: {},\n align: 'center',\n crossAlign: 'near',\n showLabelBackdrop: false,\n backdropColor: 'rgba(255, 255, 255, 0.75)',\n backdropPadding: 2,\n }\n});\ndefaults.route('scale.ticks', 'color', '', 'color');\ndefaults.route('scale.grid', 'color', '', 'borderColor');\ndefaults.route('scale.grid', 'borderColor', '', 'borderColor');\ndefaults.route('scale.title', 'color', '', 'color');\ndefaults.describe('scale', {\n _fallback: false,\n _scriptable: (name) => !name.startsWith('before') && !name.startsWith('after') && name !== 'callback' && name !== 'parser',\n _indexable: (name) => name !== 'borderDash' && name !== 'tickBorderDash',\n});\ndefaults.describe('scales', {\n _fallback: 'scale',\n});\ndefaults.describe('scale.ticks', {\n _scriptable: (name) => name !== 'backdropPadding' && name !== 'callback',\n _indexable: (name) => name !== 'backdropPadding',\n});\n\nfunction autoSkip(scale, ticks) {\n const tickOpts = scale.options.ticks;\n const ticksLimit = tickOpts.maxTicksLimit || determineMaxTicks(scale);\n const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : [];\n const numMajorIndices = majorIndices.length;\n const first = majorIndices[0];\n const last = majorIndices[numMajorIndices - 1];\n const newTicks = [];\n if (numMajorIndices > ticksLimit) {\n skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit);\n return newTicks;\n }\n const spacing = calculateSpacing(majorIndices, ticks, ticksLimit);\n if (numMajorIndices > 0) {\n let i, ilen;\n const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null;\n skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first);\n for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) {\n skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]);\n }\n skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing);\n return newTicks;\n }\n skip(ticks, newTicks, spacing);\n return newTicks;\n}\nfunction determineMaxTicks(scale) {\n const offset = scale.options.offset;\n const tickLength = scale._tickSize();\n const maxScale = scale._length / tickLength + (offset ? 0 : 1);\n const maxChart = scale._maxLength / tickLength;\n return Math.floor(Math.min(maxScale, maxChart));\n}\nfunction calculateSpacing(majorIndices, ticks, ticksLimit) {\n const evenMajorSpacing = getEvenSpacing(majorIndices);\n const spacing = ticks.length / ticksLimit;\n if (!evenMajorSpacing) {\n return Math.max(spacing, 1);\n }\n const factors = _factorize(evenMajorSpacing);\n for (let i = 0, ilen = factors.length - 1; i < ilen; i++) {\n const factor = factors[i];\n if (factor > spacing) {\n return factor;\n }\n }\n return Math.max(spacing, 1);\n}\nfunction getMajorIndices(ticks) {\n const result = [];\n let i, ilen;\n for (i = 0, ilen = ticks.length; i < ilen; i++) {\n if (ticks[i].major) {\n result.push(i);\n }\n }\n return result;\n}\nfunction skipMajors(ticks, newTicks, majorIndices, spacing) {\n let count = 0;\n let next = majorIndices[0];\n let i;\n spacing = Math.ceil(spacing);\n for (i = 0; i < ticks.length; i++) {\n if (i === next) {\n newTicks.push(ticks[i]);\n count++;\n next = majorIndices[count * spacing];\n }\n }\n}\nfunction skip(ticks, newTicks, spacing, majorStart, majorEnd) {\n const start = valueOrDefault(majorStart, 0);\n const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length);\n let count = 0;\n let length, i, next;\n spacing = Math.ceil(spacing);\n if (majorEnd) {\n length = majorEnd - majorStart;\n spacing = length / Math.floor(length / spacing);\n }\n next = start;\n while (next < 0) {\n count++;\n next = Math.round(start + count * spacing);\n }\n for (i = Math.max(start, 0); i < end; i++) {\n if (i === next) {\n newTicks.push(ticks[i]);\n count++;\n next = Math.round(start + count * spacing);\n }\n }\n}\nfunction getEvenSpacing(arr) {\n const len = arr.length;\n let i, diff;\n if (len < 2) {\n return false;\n }\n for (diff = arr[0], i = 1; i < len; ++i) {\n if (arr[i] - arr[i - 1] !== diff) {\n return false;\n }\n }\n return diff;\n}\n\nconst reverseAlign = (align) => align === 'left' ? 'right' : align === 'right' ? 'left' : align;\nconst offsetFromEdge = (scale, edge, offset) => edge === 'top' || edge === 'left' ? scale[edge] + offset : scale[edge] - offset;\nfunction sample(arr, numItems) {\n const result = [];\n const increment = arr.length / numItems;\n const len = arr.length;\n let i = 0;\n for (; i < len; i += increment) {\n result.push(arr[Math.floor(i)]);\n }\n return result;\n}\nfunction getPixelForGridLine(scale, index, offsetGridLines) {\n const length = scale.ticks.length;\n const validIndex = Math.min(index, length - 1);\n const start = scale._startPixel;\n const end = scale._endPixel;\n const epsilon = 1e-6;\n let lineValue = scale.getPixelForTick(validIndex);\n let offset;\n if (offsetGridLines) {\n if (length === 1) {\n offset = Math.max(lineValue - start, end - lineValue);\n } else if (index === 0) {\n offset = (scale.getPixelForTick(1) - lineValue) / 2;\n } else {\n offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2;\n }\n lineValue += validIndex < index ? offset : -offset;\n if (lineValue < start - epsilon || lineValue > end + epsilon) {\n return;\n }\n }\n return lineValue;\n}\nfunction garbageCollect(caches, length) {\n each(caches, (cache) => {\n const gc = cache.gc;\n const gcLen = gc.length / 2;\n let i;\n if (gcLen > length) {\n for (i = 0; i < gcLen; ++i) {\n delete cache.data[gc[i]];\n }\n gc.splice(0, gcLen);\n }\n });\n}\nfunction getTickMarkLength(options) {\n return options.drawTicks ? options.tickLength : 0;\n}\nfunction getTitleHeight(options, fallback) {\n if (!options.display) {\n return 0;\n }\n const font = toFont(options.font, fallback);\n const padding = toPadding(options.padding);\n const lines = isArray(options.text) ? options.text.length : 1;\n return (lines * font.lineHeight) + padding.height;\n}\nfunction createScaleContext(parent, scale) {\n return createContext(parent, {\n scale,\n type: 'scale'\n });\n}\nfunction createTickContext(parent, index, tick) {\n return createContext(parent, {\n tick,\n index,\n type: 'tick'\n });\n}\nfunction titleAlign(align, position, reverse) {\n let ret = _toLeftRightCenter(align);\n if ((reverse && position !== 'right') || (!reverse && position === 'right')) {\n ret = reverseAlign(ret);\n }\n return ret;\n}\nfunction titleArgs(scale, offset, position, align) {\n const {top, left, bottom, right, chart} = scale;\n const {chartArea, scales} = chart;\n let rotation = 0;\n let maxWidth, titleX, titleY;\n const height = bottom - top;\n const width = right - left;\n if (scale.isHorizontal()) {\n titleX = _alignStartEnd(align, left, right);\n if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n titleY = scales[positionAxisID].getPixelForValue(value) + height - offset;\n } else if (position === 'center') {\n titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset;\n } else {\n titleY = offsetFromEdge(scale, position, offset);\n }\n maxWidth = right - left;\n } else {\n if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n titleX = scales[positionAxisID].getPixelForValue(value) - width + offset;\n } else if (position === 'center') {\n titleX = (chartArea.left + chartArea.right) / 2 - width + offset;\n } else {\n titleX = offsetFromEdge(scale, position, offset);\n }\n titleY = _alignStartEnd(align, bottom, top);\n rotation = position === 'left' ? -HALF_PI : HALF_PI;\n }\n return {titleX, titleY, maxWidth, rotation};\n}\nclass Scale extends Element {\n constructor(cfg) {\n super();\n this.id = cfg.id;\n this.type = cfg.type;\n this.options = undefined;\n this.ctx = cfg.ctx;\n this.chart = cfg.chart;\n this.top = undefined;\n this.bottom = undefined;\n this.left = undefined;\n this.right = undefined;\n this.width = undefined;\n this.height = undefined;\n this._margins = {\n left: 0,\n right: 0,\n top: 0,\n bottom: 0\n };\n this.maxWidth = undefined;\n this.maxHeight = undefined;\n this.paddingTop = undefined;\n this.paddingBottom = undefined;\n this.paddingLeft = undefined;\n this.paddingRight = undefined;\n this.axis = undefined;\n this.labelRotation = undefined;\n this.min = undefined;\n this.max = undefined;\n this._range = undefined;\n this.ticks = [];\n this._gridLineItems = null;\n this._labelItems = null;\n this._labelSizes = null;\n this._length = 0;\n this._maxLength = 0;\n this._longestTextCache = {};\n this._startPixel = undefined;\n this._endPixel = undefined;\n this._reversePixels = false;\n this._userMax = undefined;\n this._userMin = undefined;\n this._suggestedMax = undefined;\n this._suggestedMin = undefined;\n this._ticksLength = 0;\n this._borderValue = 0;\n this._cache = {};\n this._dataLimitsCached = false;\n this.$context = undefined;\n }\n init(options) {\n this.options = options.setContext(this.getContext());\n this.axis = options.axis;\n this._userMin = this.parse(options.min);\n this._userMax = this.parse(options.max);\n this._suggestedMin = this.parse(options.suggestedMin);\n this._suggestedMax = this.parse(options.suggestedMax);\n }\n parse(raw, index) {\n return raw;\n }\n getUserBounds() {\n let {_userMin, _userMax, _suggestedMin, _suggestedMax} = this;\n _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY);\n _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY);\n _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY);\n _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY);\n return {\n min: finiteOrDefault(_userMin, _suggestedMin),\n max: finiteOrDefault(_userMax, _suggestedMax),\n minDefined: isNumberFinite(_userMin),\n maxDefined: isNumberFinite(_userMax)\n };\n }\n getMinMax(canStack) {\n let {min, max, minDefined, maxDefined} = this.getUserBounds();\n let range;\n if (minDefined && maxDefined) {\n return {min, max};\n }\n const metas = this.getMatchingVisibleMetas();\n for (let i = 0, ilen = metas.length; i < ilen; ++i) {\n range = metas[i].controller.getMinMax(this, canStack);\n if (!minDefined) {\n min = Math.min(min, range.min);\n }\n if (!maxDefined) {\n max = Math.max(max, range.max);\n }\n }\n min = maxDefined && min > max ? max : min;\n max = minDefined && min > max ? min : max;\n return {\n min: finiteOrDefault(min, finiteOrDefault(max, min)),\n max: finiteOrDefault(max, finiteOrDefault(min, max))\n };\n }\n getPadding() {\n return {\n left: this.paddingLeft || 0,\n top: this.paddingTop || 0,\n right: this.paddingRight || 0,\n bottom: this.paddingBottom || 0\n };\n }\n getTicks() {\n return this.ticks;\n }\n getLabels() {\n const data = this.chart.data;\n return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || [];\n }\n beforeLayout() {\n this._cache = {};\n this._dataLimitsCached = false;\n }\n beforeUpdate() {\n callback(this.options.beforeUpdate, [this]);\n }\n update(maxWidth, maxHeight, margins) {\n const {beginAtZero, grace, ticks: tickOpts} = this.options;\n const sampleSize = tickOpts.sampleSize;\n this.beforeUpdate();\n this.maxWidth = maxWidth;\n this.maxHeight = maxHeight;\n this._margins = margins = Object.assign({\n left: 0,\n right: 0,\n top: 0,\n bottom: 0\n }, margins);\n this.ticks = null;\n this._labelSizes = null;\n this._gridLineItems = null;\n this._labelItems = null;\n this.beforeSetDimensions();\n this.setDimensions();\n this.afterSetDimensions();\n this._maxLength = this.isHorizontal()\n ? this.width + margins.left + margins.right\n : this.height + margins.top + margins.bottom;\n if (!this._dataLimitsCached) {\n this.beforeDataLimits();\n this.determineDataLimits();\n this.afterDataLimits();\n this._range = _addGrace(this, grace, beginAtZero);\n this._dataLimitsCached = true;\n }\n this.beforeBuildTicks();\n this.ticks = this.buildTicks() || [];\n this.afterBuildTicks();\n const samplingEnabled = sampleSize < this.ticks.length;\n this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks);\n this.configure();\n this.beforeCalculateLabelRotation();\n this.calculateLabelRotation();\n this.afterCalculateLabelRotation();\n if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto')) {\n this.ticks = autoSkip(this, this.ticks);\n this._labelSizes = null;\n this.afterAutoSkip();\n }\n if (samplingEnabled) {\n this._convertTicksToLabels(this.ticks);\n }\n this.beforeFit();\n this.fit();\n this.afterFit();\n this.afterUpdate();\n }\n configure() {\n let reversePixels = this.options.reverse;\n let startPixel, endPixel;\n if (this.isHorizontal()) {\n startPixel = this.left;\n endPixel = this.right;\n } else {\n startPixel = this.top;\n endPixel = this.bottom;\n reversePixels = !reversePixels;\n }\n this._startPixel = startPixel;\n this._endPixel = endPixel;\n this._reversePixels = reversePixels;\n this._length = endPixel - startPixel;\n this._alignToPixels = this.options.alignToPixels;\n }\n afterUpdate() {\n callback(this.options.afterUpdate, [this]);\n }\n beforeSetDimensions() {\n callback(this.options.beforeSetDimensions, [this]);\n }\n setDimensions() {\n if (this.isHorizontal()) {\n this.width = this.maxWidth;\n this.left = 0;\n this.right = this.width;\n } else {\n this.height = this.maxHeight;\n this.top = 0;\n this.bottom = this.height;\n }\n this.paddingLeft = 0;\n this.paddingTop = 0;\n this.paddingRight = 0;\n this.paddingBottom = 0;\n }\n afterSetDimensions() {\n callback(this.options.afterSetDimensions, [this]);\n }\n _callHooks(name) {\n this.chart.notifyPlugins(name, this.getContext());\n callback(this.options[name], [this]);\n }\n beforeDataLimits() {\n this._callHooks('beforeDataLimits');\n }\n determineDataLimits() {}\n afterDataLimits() {\n this._callHooks('afterDataLimits');\n }\n beforeBuildTicks() {\n this._callHooks('beforeBuildTicks');\n }\n buildTicks() {\n return [];\n }\n afterBuildTicks() {\n this._callHooks('afterBuildTicks');\n }\n beforeTickToLabelConversion() {\n callback(this.options.beforeTickToLabelConversion, [this]);\n }\n generateTickLabels(ticks) {\n const tickOpts = this.options.ticks;\n let i, ilen, tick;\n for (i = 0, ilen = ticks.length; i < ilen; i++) {\n tick = ticks[i];\n tick.label = callback(tickOpts.callback, [tick.value, i, ticks], this);\n }\n }\n afterTickToLabelConversion() {\n callback(this.options.afterTickToLabelConversion, [this]);\n }\n beforeCalculateLabelRotation() {\n callback(this.options.beforeCalculateLabelRotation, [this]);\n }\n calculateLabelRotation() {\n const options = this.options;\n const tickOpts = options.ticks;\n const numTicks = this.ticks.length;\n const minRotation = tickOpts.minRotation || 0;\n const maxRotation = tickOpts.maxRotation;\n let labelRotation = minRotation;\n let tickWidth, maxHeight, maxLabelDiagonal;\n if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) {\n this.labelRotation = minRotation;\n return;\n }\n const labelSizes = this._getLabelSizes();\n const maxLabelWidth = labelSizes.widest.width;\n const maxLabelHeight = labelSizes.highest.height;\n const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth);\n tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1);\n if (maxLabelWidth + 6 > tickWidth) {\n tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1));\n maxHeight = this.maxHeight - getTickMarkLength(options.grid)\n\t\t\t\t- tickOpts.padding - getTitleHeight(options.title, this.chart.options.font);\n maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight);\n labelRotation = toDegrees(Math.min(\n Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)),\n Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1))\n ));\n labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation));\n }\n this.labelRotation = labelRotation;\n }\n afterCalculateLabelRotation() {\n callback(this.options.afterCalculateLabelRotation, [this]);\n }\n afterAutoSkip() {}\n beforeFit() {\n callback(this.options.beforeFit, [this]);\n }\n fit() {\n const minSize = {\n width: 0,\n height: 0\n };\n const {chart, options: {ticks: tickOpts, title: titleOpts, grid: gridOpts}} = this;\n const display = this._isVisible();\n const isHorizontal = this.isHorizontal();\n if (display) {\n const titleHeight = getTitleHeight(titleOpts, chart.options.font);\n if (isHorizontal) {\n minSize.width = this.maxWidth;\n minSize.height = getTickMarkLength(gridOpts) + titleHeight;\n } else {\n minSize.height = this.maxHeight;\n minSize.width = getTickMarkLength(gridOpts) + titleHeight;\n }\n if (tickOpts.display && this.ticks.length) {\n const {first, last, widest, highest} = this._getLabelSizes();\n const tickPadding = tickOpts.padding * 2;\n const angleRadians = toRadians(this.labelRotation);\n const cos = Math.cos(angleRadians);\n const sin = Math.sin(angleRadians);\n if (isHorizontal) {\n const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height;\n minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding);\n } else {\n const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height;\n minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding);\n }\n this._calculatePadding(first, last, sin, cos);\n }\n }\n this._handleMargins();\n if (isHorizontal) {\n this.width = this._length = chart.width - this._margins.left - this._margins.right;\n this.height = minSize.height;\n } else {\n this.width = minSize.width;\n this.height = this._length = chart.height - this._margins.top - this._margins.bottom;\n }\n }\n _calculatePadding(first, last, sin, cos) {\n const {ticks: {align, padding}, position} = this.options;\n const isRotated = this.labelRotation !== 0;\n const labelsBelowTicks = position !== 'top' && this.axis === 'x';\n if (this.isHorizontal()) {\n const offsetLeft = this.getPixelForTick(0) - this.left;\n const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1);\n let paddingLeft = 0;\n let paddingRight = 0;\n if (isRotated) {\n if (labelsBelowTicks) {\n paddingLeft = cos * first.width;\n paddingRight = sin * last.height;\n } else {\n paddingLeft = sin * first.height;\n paddingRight = cos * last.width;\n }\n } else if (align === 'start') {\n paddingRight = last.width;\n } else if (align === 'end') {\n paddingLeft = first.width;\n } else if (align !== 'inner') {\n paddingLeft = first.width / 2;\n paddingRight = last.width / 2;\n }\n this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0);\n this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0);\n } else {\n let paddingTop = last.height / 2;\n let paddingBottom = first.height / 2;\n if (align === 'start') {\n paddingTop = 0;\n paddingBottom = first.height;\n } else if (align === 'end') {\n paddingTop = last.height;\n paddingBottom = 0;\n }\n this.paddingTop = paddingTop + padding;\n this.paddingBottom = paddingBottom + padding;\n }\n }\n _handleMargins() {\n if (this._margins) {\n this._margins.left = Math.max(this.paddingLeft, this._margins.left);\n this._margins.top = Math.max(this.paddingTop, this._margins.top);\n this._margins.right = Math.max(this.paddingRight, this._margins.right);\n this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom);\n }\n }\n afterFit() {\n callback(this.options.afterFit, [this]);\n }\n isHorizontal() {\n const {axis, position} = this.options;\n return position === 'top' || position === 'bottom' || axis === 'x';\n }\n isFullSize() {\n return this.options.fullSize;\n }\n _convertTicksToLabels(ticks) {\n this.beforeTickToLabelConversion();\n this.generateTickLabels(ticks);\n let i, ilen;\n for (i = 0, ilen = ticks.length; i < ilen; i++) {\n if (isNullOrUndef(ticks[i].label)) {\n ticks.splice(i, 1);\n ilen--;\n i--;\n }\n }\n this.afterTickToLabelConversion();\n }\n _getLabelSizes() {\n let labelSizes = this._labelSizes;\n if (!labelSizes) {\n const sampleSize = this.options.ticks.sampleSize;\n let ticks = this.ticks;\n if (sampleSize < ticks.length) {\n ticks = sample(ticks, sampleSize);\n }\n this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length);\n }\n return labelSizes;\n }\n _computeLabelSizes(ticks, length) {\n const {ctx, _longestTextCache: caches} = this;\n const widths = [];\n const heights = [];\n let widestLabelSize = 0;\n let highestLabelSize = 0;\n let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel;\n for (i = 0; i < length; ++i) {\n label = ticks[i].label;\n tickFont = this._resolveTickFontOptions(i);\n ctx.font = fontString = tickFont.string;\n cache = caches[fontString] = caches[fontString] || {data: {}, gc: []};\n lineHeight = tickFont.lineHeight;\n width = height = 0;\n if (!isNullOrUndef(label) && !isArray(label)) {\n width = _measureText(ctx, cache.data, cache.gc, width, label);\n height = lineHeight;\n } else if (isArray(label)) {\n for (j = 0, jlen = label.length; j < jlen; ++j) {\n nestedLabel = label[j];\n if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) {\n width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel);\n height += lineHeight;\n }\n }\n }\n widths.push(width);\n heights.push(height);\n widestLabelSize = Math.max(width, widestLabelSize);\n highestLabelSize = Math.max(height, highestLabelSize);\n }\n garbageCollect(caches, length);\n const widest = widths.indexOf(widestLabelSize);\n const highest = heights.indexOf(highestLabelSize);\n const valueAt = (idx) => ({width: widths[idx] || 0, height: heights[idx] || 0});\n return {\n first: valueAt(0),\n last: valueAt(length - 1),\n widest: valueAt(widest),\n highest: valueAt(highest),\n widths,\n heights,\n };\n }\n getLabelForValue(value) {\n return value;\n }\n getPixelForValue(value, index) {\n return NaN;\n }\n getValueForPixel(pixel) {}\n getPixelForTick(index) {\n const ticks = this.ticks;\n if (index < 0 || index > ticks.length - 1) {\n return null;\n }\n return this.getPixelForValue(ticks[index].value);\n }\n getPixelForDecimal(decimal) {\n if (this._reversePixels) {\n decimal = 1 - decimal;\n }\n const pixel = this._startPixel + decimal * this._length;\n return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel);\n }\n getDecimalForPixel(pixel) {\n const decimal = (pixel - this._startPixel) / this._length;\n return this._reversePixels ? 1 - decimal : decimal;\n }\n getBasePixel() {\n return this.getPixelForValue(this.getBaseValue());\n }\n getBaseValue() {\n const {min, max} = this;\n return min < 0 && max < 0 ? max :\n min > 0 && max > 0 ? min :\n 0;\n }\n getContext(index) {\n const ticks = this.ticks || [];\n if (index >= 0 && index < ticks.length) {\n const tick = ticks[index];\n return tick.$context ||\n\t\t\t\t(tick.$context = createTickContext(this.getContext(), index, tick));\n }\n return this.$context ||\n\t\t\t(this.$context = createScaleContext(this.chart.getContext(), this));\n }\n _tickSize() {\n const optionTicks = this.options.ticks;\n const rot = toRadians(this.labelRotation);\n const cos = Math.abs(Math.cos(rot));\n const sin = Math.abs(Math.sin(rot));\n const labelSizes = this._getLabelSizes();\n const padding = optionTicks.autoSkipPadding || 0;\n const w = labelSizes ? labelSizes.widest.width + padding : 0;\n const h = labelSizes ? labelSizes.highest.height + padding : 0;\n return this.isHorizontal()\n ? h * cos > w * sin ? w / cos : h / sin\n : h * sin < w * cos ? h / cos : w / sin;\n }\n _isVisible() {\n const display = this.options.display;\n if (display !== 'auto') {\n return !!display;\n }\n return this.getMatchingVisibleMetas().length > 0;\n }\n _computeGridLineItems(chartArea) {\n const axis = this.axis;\n const chart = this.chart;\n const options = this.options;\n const {grid, position} = options;\n const offset = grid.offset;\n const isHorizontal = this.isHorizontal();\n const ticks = this.ticks;\n const ticksLength = ticks.length + (offset ? 1 : 0);\n const tl = getTickMarkLength(grid);\n const items = [];\n const borderOpts = grid.setContext(this.getContext());\n const axisWidth = borderOpts.drawBorder ? borderOpts.borderWidth : 0;\n const axisHalfWidth = axisWidth / 2;\n const alignBorderValue = function(pixel) {\n return _alignPixel(chart, pixel, axisWidth);\n };\n let borderValue, i, lineValue, alignedLineValue;\n let tx1, ty1, tx2, ty2, x1, y1, x2, y2;\n if (position === 'top') {\n borderValue = alignBorderValue(this.bottom);\n ty1 = this.bottom - tl;\n ty2 = borderValue - axisHalfWidth;\n y1 = alignBorderValue(chartArea.top) + axisHalfWidth;\n y2 = chartArea.bottom;\n } else if (position === 'bottom') {\n borderValue = alignBorderValue(this.top);\n y1 = chartArea.top;\n y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth;\n ty1 = borderValue + axisHalfWidth;\n ty2 = this.top + tl;\n } else if (position === 'left') {\n borderValue = alignBorderValue(this.right);\n tx1 = this.right - tl;\n tx2 = borderValue - axisHalfWidth;\n x1 = alignBorderValue(chartArea.left) + axisHalfWidth;\n x2 = chartArea.right;\n } else if (position === 'right') {\n borderValue = alignBorderValue(this.left);\n x1 = chartArea.left;\n x2 = alignBorderValue(chartArea.right) - axisHalfWidth;\n tx1 = borderValue + axisHalfWidth;\n tx2 = this.left + tl;\n } else if (axis === 'x') {\n if (position === 'center') {\n borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5);\n } else if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));\n }\n y1 = chartArea.top;\n y2 = chartArea.bottom;\n ty1 = borderValue + axisHalfWidth;\n ty2 = ty1 + tl;\n } else if (axis === 'y') {\n if (position === 'center') {\n borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2);\n } else if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value));\n }\n tx1 = borderValue - axisHalfWidth;\n tx2 = tx1 - tl;\n x1 = chartArea.left;\n x2 = chartArea.right;\n }\n const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength);\n const step = Math.max(1, Math.ceil(ticksLength / limit));\n for (i = 0; i < ticksLength; i += step) {\n const optsAtIndex = grid.setContext(this.getContext(i));\n const lineWidth = optsAtIndex.lineWidth;\n const lineColor = optsAtIndex.color;\n const borderDash = grid.borderDash || [];\n const borderDashOffset = optsAtIndex.borderDashOffset;\n const tickWidth = optsAtIndex.tickWidth;\n const tickColor = optsAtIndex.tickColor;\n const tickBorderDash = optsAtIndex.tickBorderDash || [];\n const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset;\n lineValue = getPixelForGridLine(this, i, offset);\n if (lineValue === undefined) {\n continue;\n }\n alignedLineValue = _alignPixel(chart, lineValue, lineWidth);\n if (isHorizontal) {\n tx1 = tx2 = x1 = x2 = alignedLineValue;\n } else {\n ty1 = ty2 = y1 = y2 = alignedLineValue;\n }\n items.push({\n tx1,\n ty1,\n tx2,\n ty2,\n x1,\n y1,\n x2,\n y2,\n width: lineWidth,\n color: lineColor,\n borderDash,\n borderDashOffset,\n tickWidth,\n tickColor,\n tickBorderDash,\n tickBorderDashOffset,\n });\n }\n this._ticksLength = ticksLength;\n this._borderValue = borderValue;\n return items;\n }\n _computeLabelItems(chartArea) {\n const axis = this.axis;\n const options = this.options;\n const {position, ticks: optionTicks} = options;\n const isHorizontal = this.isHorizontal();\n const ticks = this.ticks;\n const {align, crossAlign, padding, mirror} = optionTicks;\n const tl = getTickMarkLength(options.grid);\n const tickAndPadding = tl + padding;\n const hTickAndPadding = mirror ? -padding : tickAndPadding;\n const rotation = -toRadians(this.labelRotation);\n const items = [];\n let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset;\n let textBaseline = 'middle';\n if (position === 'top') {\n y = this.bottom - hTickAndPadding;\n textAlign = this._getXAxisLabelAlignment();\n } else if (position === 'bottom') {\n y = this.top + hTickAndPadding;\n textAlign = this._getXAxisLabelAlignment();\n } else if (position === 'left') {\n const ret = this._getYAxisLabelAlignment(tl);\n textAlign = ret.textAlign;\n x = ret.x;\n } else if (position === 'right') {\n const ret = this._getYAxisLabelAlignment(tl);\n textAlign = ret.textAlign;\n x = ret.x;\n } else if (axis === 'x') {\n if (position === 'center') {\n y = ((chartArea.top + chartArea.bottom) / 2) + tickAndPadding;\n } else if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n y = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding;\n }\n textAlign = this._getXAxisLabelAlignment();\n } else if (axis === 'y') {\n if (position === 'center') {\n x = ((chartArea.left + chartArea.right) / 2) - tickAndPadding;\n } else if (isObject(position)) {\n const positionAxisID = Object.keys(position)[0];\n const value = position[positionAxisID];\n x = this.chart.scales[positionAxisID].getPixelForValue(value);\n }\n textAlign = this._getYAxisLabelAlignment(tl).textAlign;\n }\n if (axis === 'y') {\n if (align === 'start') {\n textBaseline = 'top';\n } else if (align === 'end') {\n textBaseline = 'bottom';\n }\n }\n const labelSizes = this._getLabelSizes();\n for (i = 0, ilen = ticks.length; i < ilen; ++i) {\n tick = ticks[i];\n label = tick.label;\n const optsAtIndex = optionTicks.setContext(this.getContext(i));\n pixel = this.getPixelForTick(i) + optionTicks.labelOffset;\n font = this._resolveTickFontOptions(i);\n lineHeight = font.lineHeight;\n lineCount = isArray(label) ? label.length : 1;\n const halfCount = lineCount / 2;\n const color = optsAtIndex.color;\n const strokeColor = optsAtIndex.textStrokeColor;\n const strokeWidth = optsAtIndex.textStrokeWidth;\n let tickTextAlign = textAlign;\n if (isHorizontal) {\n x = pixel;\n if (textAlign === 'inner') {\n if (i === ilen - 1) {\n tickTextAlign = !this.options.reverse ? 'right' : 'left';\n } else if (i === 0) {\n tickTextAlign = !this.options.reverse ? 'left' : 'right';\n } else {\n tickTextAlign = 'center';\n }\n }\n if (position === 'top') {\n if (crossAlign === 'near' || rotation !== 0) {\n textOffset = -lineCount * lineHeight + lineHeight / 2;\n } else if (crossAlign === 'center') {\n textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight;\n } else {\n textOffset = -labelSizes.highest.height + lineHeight / 2;\n }\n } else {\n if (crossAlign === 'near' || rotation !== 0) {\n textOffset = lineHeight / 2;\n } else if (crossAlign === 'center') {\n textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight;\n } else {\n textOffset = labelSizes.highest.height - lineCount * lineHeight;\n }\n }\n if (mirror) {\n textOffset *= -1;\n }\n } else {\n y = pixel;\n textOffset = (1 - lineCount) * lineHeight / 2;\n }\n let backdrop;\n if (optsAtIndex.showLabelBackdrop) {\n const labelPadding = toPadding(optsAtIndex.backdropPadding);\n const height = labelSizes.heights[i];\n const width = labelSizes.widths[i];\n let top = y + textOffset - labelPadding.top;\n let left = x - labelPadding.left;\n switch (textBaseline) {\n case 'middle':\n top -= height / 2;\n break;\n case 'bottom':\n top -= height;\n break;\n }\n switch (textAlign) {\n case 'center':\n left -= width / 2;\n break;\n case 'right':\n left -= width;\n break;\n }\n backdrop = {\n left,\n top,\n width: width + labelPadding.width,\n height: height + labelPadding.height,\n color: optsAtIndex.backdropColor,\n };\n }\n items.push({\n rotation,\n label,\n font,\n color,\n strokeColor,\n strokeWidth,\n textOffset,\n textAlign: tickTextAlign,\n textBaseline,\n translation: [x, y],\n backdrop,\n });\n }\n return items;\n }\n _getXAxisLabelAlignment() {\n const {position, ticks} = this.options;\n const rotation = -toRadians(this.labelRotation);\n if (rotation) {\n return position === 'top' ? 'left' : 'right';\n }\n let align = 'center';\n if (ticks.align === 'start') {\n align = 'left';\n } else if (ticks.align === 'end') {\n align = 'right';\n } else if (ticks.align === 'inner') {\n align = 'inner';\n }\n return align;\n }\n _getYAxisLabelAlignment(tl) {\n const {position, ticks: {crossAlign, mirror, padding}} = this.options;\n const labelSizes = this._getLabelSizes();\n const tickAndPadding = tl + padding;\n const widest = labelSizes.widest.width;\n let textAlign;\n let x;\n if (position === 'left') {\n if (mirror) {\n x = this.right + padding;\n if (crossAlign === 'near') {\n textAlign = 'left';\n } else if (crossAlign === 'center') {\n textAlign = 'center';\n x += (widest / 2);\n } else {\n textAlign = 'right';\n x += widest;\n }\n } else {\n x = this.right - tickAndPadding;\n if (crossAlign === 'near') {\n textAlign = 'right';\n } else if (crossAlign === 'center') {\n textAlign = 'center';\n x -= (widest / 2);\n } else {\n textAlign = 'left';\n x = this.left;\n }\n }\n } else if (position === 'right') {\n if (mirror) {\n x = this.left + padding;\n if (crossAlign === 'near') {\n textAlign = 'right';\n } else if (crossAlign === 'center') {\n textAlign = 'center';\n x -= (widest / 2);\n } else {\n textAlign = 'left';\n x -= widest;\n }\n } else {\n x = this.left + tickAndPadding;\n if (crossAlign === 'near') {\n textAlign = 'left';\n } else if (crossAlign === 'center') {\n textAlign = 'center';\n x += widest / 2;\n } else {\n textAlign = 'right';\n x = this.right;\n }\n }\n } else {\n textAlign = 'right';\n }\n return {textAlign, x};\n }\n _computeLabelArea() {\n if (this.options.ticks.mirror) {\n return;\n }\n const chart = this.chart;\n const position = this.options.position;\n if (position === 'left' || position === 'right') {\n return {top: 0, left: this.left, bottom: chart.height, right: this.right};\n } if (position === 'top' || position === 'bottom') {\n return {top: this.top, left: 0, bottom: this.bottom, right: chart.width};\n }\n }\n drawBackground() {\n const {ctx, options: {backgroundColor}, left, top, width, height} = this;\n if (backgroundColor) {\n ctx.save();\n ctx.fillStyle = backgroundColor;\n ctx.fillRect(left, top, width, height);\n ctx.restore();\n }\n }\n getLineWidthForValue(value) {\n const grid = this.options.grid;\n if (!this._isVisible() || !grid.display) {\n return 0;\n }\n const ticks = this.ticks;\n const index = ticks.findIndex(t => t.value === value);\n if (index >= 0) {\n const opts = grid.setContext(this.getContext(index));\n return opts.lineWidth;\n }\n return 0;\n }\n drawGrid(chartArea) {\n const grid = this.options.grid;\n const ctx = this.ctx;\n const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea));\n let i, ilen;\n const drawLine = (p1, p2, style) => {\n if (!style.width || !style.color) {\n return;\n }\n ctx.save();\n ctx.lineWidth = style.width;\n ctx.strokeStyle = style.color;\n ctx.setLineDash(style.borderDash || []);\n ctx.lineDashOffset = style.borderDashOffset;\n ctx.beginPath();\n ctx.moveTo(p1.x, p1.y);\n ctx.lineTo(p2.x, p2.y);\n ctx.stroke();\n ctx.restore();\n };\n if (grid.display) {\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n const item = items[i];\n if (grid.drawOnChartArea) {\n drawLine(\n {x: item.x1, y: item.y1},\n {x: item.x2, y: item.y2},\n item\n );\n }\n if (grid.drawTicks) {\n drawLine(\n {x: item.tx1, y: item.ty1},\n {x: item.tx2, y: item.ty2},\n {\n color: item.tickColor,\n width: item.tickWidth,\n borderDash: item.tickBorderDash,\n borderDashOffset: item.tickBorderDashOffset\n }\n );\n }\n }\n }\n }\n drawBorder() {\n const {chart, ctx, options: {grid}} = this;\n const borderOpts = grid.setContext(this.getContext());\n const axisWidth = grid.drawBorder ? borderOpts.borderWidth : 0;\n if (!axisWidth) {\n return;\n }\n const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth;\n const borderValue = this._borderValue;\n let x1, x2, y1, y2;\n if (this.isHorizontal()) {\n x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2;\n x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2;\n y1 = y2 = borderValue;\n } else {\n y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2;\n y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2;\n x1 = x2 = borderValue;\n }\n ctx.save();\n ctx.lineWidth = borderOpts.borderWidth;\n ctx.strokeStyle = borderOpts.borderColor;\n ctx.beginPath();\n ctx.moveTo(x1, y1);\n ctx.lineTo(x2, y2);\n ctx.stroke();\n ctx.restore();\n }\n drawLabels(chartArea) {\n const optionTicks = this.options.ticks;\n if (!optionTicks.display) {\n return;\n }\n const ctx = this.ctx;\n const area = this._computeLabelArea();\n if (area) {\n clipArea(ctx, area);\n }\n const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea));\n let i, ilen;\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n const item = items[i];\n const tickFont = item.font;\n const label = item.label;\n if (item.backdrop) {\n ctx.fillStyle = item.backdrop.color;\n ctx.fillRect(item.backdrop.left, item.backdrop.top, item.backdrop.width, item.backdrop.height);\n }\n let y = item.textOffset;\n renderText(ctx, label, 0, y, tickFont, item);\n }\n if (area) {\n unclipArea(ctx);\n }\n }\n drawTitle() {\n const {ctx, options: {position, title, reverse}} = this;\n if (!title.display) {\n return;\n }\n const font = toFont(title.font);\n const padding = toPadding(title.padding);\n const align = title.align;\n let offset = font.lineHeight / 2;\n if (position === 'bottom' || position === 'center' || isObject(position)) {\n offset += padding.bottom;\n if (isArray(title.text)) {\n offset += font.lineHeight * (title.text.length - 1);\n }\n } else {\n offset += padding.top;\n }\n const {titleX, titleY, maxWidth, rotation} = titleArgs(this, offset, position, align);\n renderText(ctx, title.text, 0, 0, font, {\n color: title.color,\n maxWidth,\n rotation,\n textAlign: titleAlign(align, position, reverse),\n textBaseline: 'middle',\n translation: [titleX, titleY],\n });\n }\n draw(chartArea) {\n if (!this._isVisible()) {\n return;\n }\n this.drawBackground();\n this.drawGrid(chartArea);\n this.drawBorder();\n this.drawTitle();\n this.drawLabels(chartArea);\n }\n _layers() {\n const opts = this.options;\n const tz = opts.ticks && opts.ticks.z || 0;\n const gz = valueOrDefault(opts.grid && opts.grid.z, -1);\n if (!this._isVisible() || this.draw !== Scale.prototype.draw) {\n return [{\n z: tz,\n draw: (chartArea) => {\n this.draw(chartArea);\n }\n }];\n }\n return [{\n z: gz,\n draw: (chartArea) => {\n this.drawBackground();\n this.drawGrid(chartArea);\n this.drawTitle();\n }\n }, {\n z: gz + 1,\n draw: () => {\n this.drawBorder();\n }\n }, {\n z: tz,\n draw: (chartArea) => {\n this.drawLabels(chartArea);\n }\n }];\n }\n getMatchingVisibleMetas(type) {\n const metas = this.chart.getSortedVisibleDatasetMetas();\n const axisID = this.axis + 'AxisID';\n const result = [];\n let i, ilen;\n for (i = 0, ilen = metas.length; i < ilen; ++i) {\n const meta = metas[i];\n if (meta[axisID] === this.id && (!type || meta.type === type)) {\n result.push(meta);\n }\n }\n return result;\n }\n _resolveTickFontOptions(index) {\n const opts = this.options.ticks.setContext(this.getContext(index));\n return toFont(opts.font);\n }\n _maxDigits() {\n const fontSize = this._resolveTickFontOptions(0).lineHeight;\n return (this.isHorizontal() ? this.width : this.height) / fontSize;\n }\n}\n\nclass TypedRegistry {\n constructor(type, scope, override) {\n this.type = type;\n this.scope = scope;\n this.override = override;\n this.items = Object.create(null);\n }\n isForType(type) {\n return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype);\n }\n register(item) {\n const proto = Object.getPrototypeOf(item);\n let parentScope;\n if (isIChartComponent(proto)) {\n parentScope = this.register(proto);\n }\n const items = this.items;\n const id = item.id;\n const scope = this.scope + '.' + id;\n if (!id) {\n throw new Error('class does not have id: ' + item);\n }\n if (id in items) {\n return scope;\n }\n items[id] = item;\n registerDefaults(item, scope, parentScope);\n if (this.override) {\n defaults.override(item.id, item.overrides);\n }\n return scope;\n }\n get(id) {\n return this.items[id];\n }\n unregister(item) {\n const items = this.items;\n const id = item.id;\n const scope = this.scope;\n if (id in items) {\n delete items[id];\n }\n if (scope && id in defaults[scope]) {\n delete defaults[scope][id];\n if (this.override) {\n delete overrides[id];\n }\n }\n }\n}\nfunction registerDefaults(item, scope, parentScope) {\n const itemDefaults = merge(Object.create(null), [\n parentScope ? defaults.get(parentScope) : {},\n defaults.get(scope),\n item.defaults\n ]);\n defaults.set(scope, itemDefaults);\n if (item.defaultRoutes) {\n routeDefaults(scope, item.defaultRoutes);\n }\n if (item.descriptors) {\n defaults.describe(scope, item.descriptors);\n }\n}\nfunction routeDefaults(scope, routes) {\n Object.keys(routes).forEach(property => {\n const propertyParts = property.split('.');\n const sourceName = propertyParts.pop();\n const sourceScope = [scope].concat(propertyParts).join('.');\n const parts = routes[property].split('.');\n const targetName = parts.pop();\n const targetScope = parts.join('.');\n defaults.route(sourceScope, sourceName, targetScope, targetName);\n });\n}\nfunction isIChartComponent(proto) {\n return 'id' in proto && 'defaults' in proto;\n}\n\nclass Registry {\n constructor() {\n this.controllers = new TypedRegistry(DatasetController, 'datasets', true);\n this.elements = new TypedRegistry(Element, 'elements');\n this.plugins = new TypedRegistry(Object, 'plugins');\n this.scales = new TypedRegistry(Scale, 'scales');\n this._typedRegistries = [this.controllers, this.scales, this.elements];\n }\n add(...args) {\n this._each('register', args);\n }\n remove(...args) {\n this._each('unregister', args);\n }\n addControllers(...args) {\n this._each('register', args, this.controllers);\n }\n addElements(...args) {\n this._each('register', args, this.elements);\n }\n addPlugins(...args) {\n this._each('register', args, this.plugins);\n }\n addScales(...args) {\n this._each('register', args, this.scales);\n }\n getController(id) {\n return this._get(id, this.controllers, 'controller');\n }\n getElement(id) {\n return this._get(id, this.elements, 'element');\n }\n getPlugin(id) {\n return this._get(id, this.plugins, 'plugin');\n }\n getScale(id) {\n return this._get(id, this.scales, 'scale');\n }\n removeControllers(...args) {\n this._each('unregister', args, this.controllers);\n }\n removeElements(...args) {\n this._each('unregister', args, this.elements);\n }\n removePlugins(...args) {\n this._each('unregister', args, this.plugins);\n }\n removeScales(...args) {\n this._each('unregister', args, this.scales);\n }\n _each(method, args, typedRegistry) {\n [...args].forEach(arg => {\n const reg = typedRegistry || this._getRegistryForType(arg);\n if (typedRegistry || reg.isForType(arg) || (reg === this.plugins && arg.id)) {\n this._exec(method, reg, arg);\n } else {\n each(arg, item => {\n const itemReg = typedRegistry || this._getRegistryForType(item);\n this._exec(method, itemReg, item);\n });\n }\n });\n }\n _exec(method, registry, component) {\n const camelMethod = _capitalize(method);\n callback(component['before' + camelMethod], [], component);\n registry[method](component);\n callback(component['after' + camelMethod], [], component);\n }\n _getRegistryForType(type) {\n for (let i = 0; i < this._typedRegistries.length; i++) {\n const reg = this._typedRegistries[i];\n if (reg.isForType(type)) {\n return reg;\n }\n }\n return this.plugins;\n }\n _get(id, typedRegistry, type) {\n const item = typedRegistry.get(id);\n if (item === undefined) {\n throw new Error('\"' + id + '\" is not a registered ' + type + '.');\n }\n return item;\n }\n}\nvar registry = new Registry();\n\nclass PluginService {\n constructor() {\n this._init = [];\n }\n notify(chart, hook, args, filter) {\n if (hook === 'beforeInit') {\n this._init = this._createDescriptors(chart, true);\n this._notify(this._init, chart, 'install');\n }\n const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart);\n const result = this._notify(descriptors, chart, hook, args);\n if (hook === 'afterDestroy') {\n this._notify(descriptors, chart, 'stop');\n this._notify(this._init, chart, 'uninstall');\n }\n return result;\n }\n _notify(descriptors, chart, hook, args) {\n args = args || {};\n for (const descriptor of descriptors) {\n const plugin = descriptor.plugin;\n const method = plugin[hook];\n const params = [chart, args, descriptor.options];\n if (callback(method, params, plugin) === false && args.cancelable) {\n return false;\n }\n }\n return true;\n }\n invalidate() {\n if (!isNullOrUndef(this._cache)) {\n this._oldCache = this._cache;\n this._cache = undefined;\n }\n }\n _descriptors(chart) {\n if (this._cache) {\n return this._cache;\n }\n const descriptors = this._cache = this._createDescriptors(chart);\n this._notifyStateChanges(chart);\n return descriptors;\n }\n _createDescriptors(chart, all) {\n const config = chart && chart.config;\n const options = valueOrDefault(config.options && config.options.plugins, {});\n const plugins = allPlugins(config);\n return options === false && !all ? [] : createDescriptors(chart, plugins, options, all);\n }\n _notifyStateChanges(chart) {\n const previousDescriptors = this._oldCache || [];\n const descriptors = this._cache;\n const diff = (a, b) => a.filter(x => !b.some(y => x.plugin.id === y.plugin.id));\n this._notify(diff(previousDescriptors, descriptors), chart, 'stop');\n this._notify(diff(descriptors, previousDescriptors), chart, 'start');\n }\n}\nfunction allPlugins(config) {\n const plugins = [];\n const keys = Object.keys(registry.plugins.items);\n for (let i = 0; i < keys.length; i++) {\n plugins.push(registry.getPlugin(keys[i]));\n }\n const local = config.plugins || [];\n for (let i = 0; i < local.length; i++) {\n const plugin = local[i];\n if (plugins.indexOf(plugin) === -1) {\n plugins.push(plugin);\n }\n }\n return plugins;\n}\nfunction getOpts(options, all) {\n if (!all && options === false) {\n return null;\n }\n if (options === true) {\n return {};\n }\n return options;\n}\nfunction createDescriptors(chart, plugins, options, all) {\n const result = [];\n const context = chart.getContext();\n for (let i = 0; i < plugins.length; i++) {\n const plugin = plugins[i];\n const id = plugin.id;\n const opts = getOpts(options[id], all);\n if (opts === null) {\n continue;\n }\n result.push({\n plugin,\n options: pluginOpts(chart.config, plugin, opts, context)\n });\n }\n return result;\n}\nfunction pluginOpts(config, plugin, opts, context) {\n const keys = config.pluginScopeKeys(plugin);\n const scopes = config.getOptionScopes(opts, keys);\n return config.createResolver(scopes, context, [''], {scriptable: false, indexable: false, allKeys: true});\n}\n\nfunction getIndexAxis(type, options) {\n const datasetDefaults = defaults.datasets[type] || {};\n const datasetOptions = (options.datasets || {})[type] || {};\n return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x';\n}\nfunction getAxisFromDefaultScaleID(id, indexAxis) {\n let axis = id;\n if (id === '_index_') {\n axis = indexAxis;\n } else if (id === '_value_') {\n axis = indexAxis === 'x' ? 'y' : 'x';\n }\n return axis;\n}\nfunction getDefaultScaleIDFromAxis(axis, indexAxis) {\n return axis === indexAxis ? '_index_' : '_value_';\n}\nfunction axisFromPosition(position) {\n if (position === 'top' || position === 'bottom') {\n return 'x';\n }\n if (position === 'left' || position === 'right') {\n return 'y';\n }\n}\nfunction determineAxis(id, scaleOptions) {\n if (id === 'x' || id === 'y') {\n return id;\n }\n return scaleOptions.axis || axisFromPosition(scaleOptions.position) || id.charAt(0).toLowerCase();\n}\nfunction mergeScaleConfig(config, options) {\n const chartDefaults = overrides[config.type] || {scales: {}};\n const configScales = options.scales || {};\n const chartIndexAxis = getIndexAxis(config.type, options);\n const firstIDs = Object.create(null);\n const scales = Object.create(null);\n Object.keys(configScales).forEach(id => {\n const scaleConf = configScales[id];\n if (!isObject(scaleConf)) {\n return console.error(`Invalid scale configuration for scale: ${id}`);\n }\n if (scaleConf._proxy) {\n return console.warn(`Ignoring resolver passed as options for scale: ${id}`);\n }\n const axis = determineAxis(id, scaleConf);\n const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis);\n const defaultScaleOptions = chartDefaults.scales || {};\n firstIDs[axis] = firstIDs[axis] || id;\n scales[id] = mergeIf(Object.create(null), [{axis}, scaleConf, defaultScaleOptions[axis], defaultScaleOptions[defaultId]]);\n });\n config.data.datasets.forEach(dataset => {\n const type = dataset.type || config.type;\n const indexAxis = dataset.indexAxis || getIndexAxis(type, options);\n const datasetDefaults = overrides[type] || {};\n const defaultScaleOptions = datasetDefaults.scales || {};\n Object.keys(defaultScaleOptions).forEach(defaultID => {\n const axis = getAxisFromDefaultScaleID(defaultID, indexAxis);\n const id = dataset[axis + 'AxisID'] || firstIDs[axis] || axis;\n scales[id] = scales[id] || Object.create(null);\n mergeIf(scales[id], [{axis}, configScales[id], defaultScaleOptions[defaultID]]);\n });\n });\n Object.keys(scales).forEach(key => {\n const scale = scales[key];\n mergeIf(scale, [defaults.scales[scale.type], defaults.scale]);\n });\n return scales;\n}\nfunction initOptions(config) {\n const options = config.options || (config.options = {});\n options.plugins = valueOrDefault(options.plugins, {});\n options.scales = mergeScaleConfig(config, options);\n}\nfunction initData(data) {\n data = data || {};\n data.datasets = data.datasets || [];\n data.labels = data.labels || [];\n return data;\n}\nfunction initConfig(config) {\n config = config || {};\n config.data = initData(config.data);\n initOptions(config);\n return config;\n}\nconst keyCache = new Map();\nconst keysCached = new Set();\nfunction cachedKeys(cacheKey, generate) {\n let keys = keyCache.get(cacheKey);\n if (!keys) {\n keys = generate();\n keyCache.set(cacheKey, keys);\n keysCached.add(keys);\n }\n return keys;\n}\nconst addIfFound = (set, obj, key) => {\n const opts = resolveObjectKey(obj, key);\n if (opts !== undefined) {\n set.add(opts);\n }\n};\nclass Config {\n constructor(config) {\n this._config = initConfig(config);\n this._scopeCache = new Map();\n this._resolverCache = new Map();\n }\n get platform() {\n return this._config.platform;\n }\n get type() {\n return this._config.type;\n }\n set type(type) {\n this._config.type = type;\n }\n get data() {\n return this._config.data;\n }\n set data(data) {\n this._config.data = initData(data);\n }\n get options() {\n return this._config.options;\n }\n set options(options) {\n this._config.options = options;\n }\n get plugins() {\n return this._config.plugins;\n }\n update() {\n const config = this._config;\n this.clearCache();\n initOptions(config);\n }\n clearCache() {\n this._scopeCache.clear();\n this._resolverCache.clear();\n }\n datasetScopeKeys(datasetType) {\n return cachedKeys(datasetType,\n () => [[\n `datasets.${datasetType}`,\n ''\n ]]);\n }\n datasetAnimationScopeKeys(datasetType, transition) {\n return cachedKeys(`${datasetType}.transition.${transition}`,\n () => [\n [\n `datasets.${datasetType}.transitions.${transition}`,\n `transitions.${transition}`,\n ],\n [\n `datasets.${datasetType}`,\n ''\n ]\n ]);\n }\n datasetElementScopeKeys(datasetType, elementType) {\n return cachedKeys(`${datasetType}-${elementType}`,\n () => [[\n `datasets.${datasetType}.elements.${elementType}`,\n `datasets.${datasetType}`,\n `elements.${elementType}`,\n ''\n ]]);\n }\n pluginScopeKeys(plugin) {\n const id = plugin.id;\n const type = this.type;\n return cachedKeys(`${type}-plugin-${id}`,\n () => [[\n `plugins.${id}`,\n ...plugin.additionalOptionScopes || [],\n ]]);\n }\n _cachedScopes(mainScope, resetCache) {\n const _scopeCache = this._scopeCache;\n let cache = _scopeCache.get(mainScope);\n if (!cache || resetCache) {\n cache = new Map();\n _scopeCache.set(mainScope, cache);\n }\n return cache;\n }\n getOptionScopes(mainScope, keyLists, resetCache) {\n const {options, type} = this;\n const cache = this._cachedScopes(mainScope, resetCache);\n const cached = cache.get(keyLists);\n if (cached) {\n return cached;\n }\n const scopes = new Set();\n keyLists.forEach(keys => {\n if (mainScope) {\n scopes.add(mainScope);\n keys.forEach(key => addIfFound(scopes, mainScope, key));\n }\n keys.forEach(key => addIfFound(scopes, options, key));\n keys.forEach(key => addIfFound(scopes, overrides[type] || {}, key));\n keys.forEach(key => addIfFound(scopes, defaults, key));\n keys.forEach(key => addIfFound(scopes, descriptors, key));\n });\n const array = Array.from(scopes);\n if (array.length === 0) {\n array.push(Object.create(null));\n }\n if (keysCached.has(keyLists)) {\n cache.set(keyLists, array);\n }\n return array;\n }\n chartOptionScopes() {\n const {options, type} = this;\n return [\n options,\n overrides[type] || {},\n defaults.datasets[type] || {},\n {type},\n defaults,\n descriptors\n ];\n }\n resolveNamedOptions(scopes, names, context, prefixes = ['']) {\n const result = {$shared: true};\n const {resolver, subPrefixes} = getResolver(this._resolverCache, scopes, prefixes);\n let options = resolver;\n if (needContext(resolver, names)) {\n result.$shared = false;\n context = isFunction(context) ? context() : context;\n const subResolver = this.createResolver(scopes, context, subPrefixes);\n options = _attachContext(resolver, context, subResolver);\n }\n for (const prop of names) {\n result[prop] = options[prop];\n }\n return result;\n }\n createResolver(scopes, context, prefixes = [''], descriptorDefaults) {\n const {resolver} = getResolver(this._resolverCache, scopes, prefixes);\n return isObject(context)\n ? _attachContext(resolver, context, undefined, descriptorDefaults)\n : resolver;\n }\n}\nfunction getResolver(resolverCache, scopes, prefixes) {\n let cache = resolverCache.get(scopes);\n if (!cache) {\n cache = new Map();\n resolverCache.set(scopes, cache);\n }\n const cacheKey = prefixes.join();\n let cached = cache.get(cacheKey);\n if (!cached) {\n const resolver = _createResolver(scopes, prefixes);\n cached = {\n resolver,\n subPrefixes: prefixes.filter(p => !p.toLowerCase().includes('hover'))\n };\n cache.set(cacheKey, cached);\n }\n return cached;\n}\nconst hasFunction = value => isObject(value)\n && Object.getOwnPropertyNames(value).reduce((acc, key) => acc || isFunction(value[key]), false);\nfunction needContext(proxy, names) {\n const {isScriptable, isIndexable} = _descriptors(proxy);\n for (const prop of names) {\n const scriptable = isScriptable(prop);\n const indexable = isIndexable(prop);\n const value = (indexable || scriptable) && proxy[prop];\n if ((scriptable && (isFunction(value) || hasFunction(value)))\n || (indexable && isArray(value))) {\n return true;\n }\n }\n return false;\n}\n\nvar version = \"3.8.0\";\n\nconst KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea'];\nfunction positionIsHorizontal(position, axis) {\n return position === 'top' || position === 'bottom' || (KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x');\n}\nfunction compare2Level(l1, l2) {\n return function(a, b) {\n return a[l1] === b[l1]\n ? a[l2] - b[l2]\n : a[l1] - b[l1];\n };\n}\nfunction onAnimationsComplete(context) {\n const chart = context.chart;\n const animationOptions = chart.options.animation;\n chart.notifyPlugins('afterRender');\n callback(animationOptions && animationOptions.onComplete, [context], chart);\n}\nfunction onAnimationProgress(context) {\n const chart = context.chart;\n const animationOptions = chart.options.animation;\n callback(animationOptions && animationOptions.onProgress, [context], chart);\n}\nfunction getCanvas(item) {\n if (_isDomSupported() && typeof item === 'string') {\n item = document.getElementById(item);\n } else if (item && item.length) {\n item = item[0];\n }\n if (item && item.canvas) {\n item = item.canvas;\n }\n return item;\n}\nconst instances = {};\nconst getChart = (key) => {\n const canvas = getCanvas(key);\n return Object.values(instances).filter((c) => c.canvas === canvas).pop();\n};\nfunction moveNumericKeys(obj, start, move) {\n const keys = Object.keys(obj);\n for (const key of keys) {\n const intKey = +key;\n if (intKey >= start) {\n const value = obj[key];\n delete obj[key];\n if (move > 0 || intKey > start) {\n obj[intKey + move] = value;\n }\n }\n }\n}\nfunction determineLastEvent(e, lastEvent, inChartArea, isClick) {\n if (!inChartArea || e.type === 'mouseout') {\n return null;\n }\n if (isClick) {\n return lastEvent;\n }\n return e;\n}\nclass Chart {\n constructor(item, userConfig) {\n const config = this.config = new Config(userConfig);\n const initialCanvas = getCanvas(item);\n const existingChart = getChart(initialCanvas);\n if (existingChart) {\n throw new Error(\n 'Canvas is already in use. Chart with ID \\'' + existingChart.id + '\\'' +\n\t\t\t\t' must be destroyed before the canvas can be reused.'\n );\n }\n const options = config.createResolver(config.chartOptionScopes(), this.getContext());\n this.platform = new (config.platform || _detectPlatform(initialCanvas))();\n this.platform.updateConfig(config);\n const context = this.platform.acquireContext(initialCanvas, options.aspectRatio);\n const canvas = context && context.canvas;\n const height = canvas && canvas.height;\n const width = canvas && canvas.width;\n this.id = uid();\n this.ctx = context;\n this.canvas = canvas;\n this.width = width;\n this.height = height;\n this._options = options;\n this._aspectRatio = this.aspectRatio;\n this._layers = [];\n this._metasets = [];\n this._stacks = undefined;\n this.boxes = [];\n this.currentDevicePixelRatio = undefined;\n this.chartArea = undefined;\n this._active = [];\n this._lastEvent = undefined;\n this._listeners = {};\n this._responsiveListeners = undefined;\n this._sortedMetasets = [];\n this.scales = {};\n this._plugins = new PluginService();\n this.$proxies = {};\n this._hiddenIndices = {};\n this.attached = false;\n this._animationsDisabled = undefined;\n this.$context = undefined;\n this._doResize = debounce(mode => this.update(mode), options.resizeDelay || 0);\n this._dataChanges = [];\n instances[this.id] = this;\n if (!context || !canvas) {\n console.error(\"Failed to create chart: can't acquire context from the given item\");\n return;\n }\n animator.listen(this, 'complete', onAnimationsComplete);\n animator.listen(this, 'progress', onAnimationProgress);\n this._initialize();\n if (this.attached) {\n this.update();\n }\n }\n get aspectRatio() {\n const {options: {aspectRatio, maintainAspectRatio}, width, height, _aspectRatio} = this;\n if (!isNullOrUndef(aspectRatio)) {\n return aspectRatio;\n }\n if (maintainAspectRatio && _aspectRatio) {\n return _aspectRatio;\n }\n return height ? width / height : null;\n }\n get data() {\n return this.config.data;\n }\n set data(data) {\n this.config.data = data;\n }\n get options() {\n return this._options;\n }\n set options(options) {\n this.config.options = options;\n }\n _initialize() {\n this.notifyPlugins('beforeInit');\n if (this.options.responsive) {\n this.resize();\n } else {\n retinaScale(this, this.options.devicePixelRatio);\n }\n this.bindEvents();\n this.notifyPlugins('afterInit');\n return this;\n }\n clear() {\n clearCanvas(this.canvas, this.ctx);\n return this;\n }\n stop() {\n animator.stop(this);\n return this;\n }\n resize(width, height) {\n if (!animator.running(this)) {\n this._resize(width, height);\n } else {\n this._resizeBeforeDraw = {width, height};\n }\n }\n _resize(width, height) {\n const options = this.options;\n const canvas = this.canvas;\n const aspectRatio = options.maintainAspectRatio && this.aspectRatio;\n const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio);\n const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio();\n const mode = this.width ? 'resize' : 'attach';\n this.width = newSize.width;\n this.height = newSize.height;\n this._aspectRatio = this.aspectRatio;\n if (!retinaScale(this, newRatio, true)) {\n return;\n }\n this.notifyPlugins('resize', {size: newSize});\n callback(options.onResize, [this, newSize], this);\n if (this.attached) {\n if (this._doResize(mode)) {\n this.render();\n }\n }\n }\n ensureScalesHaveIDs() {\n const options = this.options;\n const scalesOptions = options.scales || {};\n each(scalesOptions, (axisOptions, axisID) => {\n axisOptions.id = axisID;\n });\n }\n buildOrUpdateScales() {\n const options = this.options;\n const scaleOpts = options.scales;\n const scales = this.scales;\n const updated = Object.keys(scales).reduce((obj, id) => {\n obj[id] = false;\n return obj;\n }, {});\n let items = [];\n if (scaleOpts) {\n items = items.concat(\n Object.keys(scaleOpts).map((id) => {\n const scaleOptions = scaleOpts[id];\n const axis = determineAxis(id, scaleOptions);\n const isRadial = axis === 'r';\n const isHorizontal = axis === 'x';\n return {\n options: scaleOptions,\n dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left',\n dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear'\n };\n })\n );\n }\n each(items, (item) => {\n const scaleOptions = item.options;\n const id = scaleOptions.id;\n const axis = determineAxis(id, scaleOptions);\n const scaleType = valueOrDefault(scaleOptions.type, item.dtype);\n if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) {\n scaleOptions.position = item.dposition;\n }\n updated[id] = true;\n let scale = null;\n if (id in scales && scales[id].type === scaleType) {\n scale = scales[id];\n } else {\n const scaleClass = registry.getScale(scaleType);\n scale = new scaleClass({\n id,\n type: scaleType,\n ctx: this.ctx,\n chart: this\n });\n scales[scale.id] = scale;\n }\n scale.init(scaleOptions, options);\n });\n each(updated, (hasUpdated, id) => {\n if (!hasUpdated) {\n delete scales[id];\n }\n });\n each(scales, (scale) => {\n layouts.configure(this, scale, scale.options);\n layouts.addBox(this, scale);\n });\n }\n _updateMetasets() {\n const metasets = this._metasets;\n const numData = this.data.datasets.length;\n const numMeta = metasets.length;\n metasets.sort((a, b) => a.index - b.index);\n if (numMeta > numData) {\n for (let i = numData; i < numMeta; ++i) {\n this._destroyDatasetMeta(i);\n }\n metasets.splice(numData, numMeta - numData);\n }\n this._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index'));\n }\n _removeUnreferencedMetasets() {\n const {_metasets: metasets, data: {datasets}} = this;\n if (metasets.length > datasets.length) {\n delete this._stacks;\n }\n metasets.forEach((meta, index) => {\n if (datasets.filter(x => x === meta._dataset).length === 0) {\n this._destroyDatasetMeta(index);\n }\n });\n }\n buildOrUpdateControllers() {\n const newControllers = [];\n const datasets = this.data.datasets;\n let i, ilen;\n this._removeUnreferencedMetasets();\n for (i = 0, ilen = datasets.length; i < ilen; i++) {\n const dataset = datasets[i];\n let meta = this.getDatasetMeta(i);\n const type = dataset.type || this.config.type;\n if (meta.type && meta.type !== type) {\n this._destroyDatasetMeta(i);\n meta = this.getDatasetMeta(i);\n }\n meta.type = type;\n meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options);\n meta.order = dataset.order || 0;\n meta.index = i;\n meta.label = '' + dataset.label;\n meta.visible = this.isDatasetVisible(i);\n if (meta.controller) {\n meta.controller.updateIndex(i);\n meta.controller.linkScales();\n } else {\n const ControllerClass = registry.getController(type);\n const {datasetElementType, dataElementType} = defaults.datasets[type];\n Object.assign(ControllerClass.prototype, {\n dataElementType: registry.getElement(dataElementType),\n datasetElementType: datasetElementType && registry.getElement(datasetElementType)\n });\n meta.controller = new ControllerClass(this, i);\n newControllers.push(meta.controller);\n }\n }\n this._updateMetasets();\n return newControllers;\n }\n _resetElements() {\n each(this.data.datasets, (dataset, datasetIndex) => {\n this.getDatasetMeta(datasetIndex).controller.reset();\n }, this);\n }\n reset() {\n this._resetElements();\n this.notifyPlugins('reset');\n }\n update(mode) {\n const config = this.config;\n config.update();\n const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());\n const animsDisabled = this._animationsDisabled = !options.animation;\n this._updateScales();\n this._checkEventBindings();\n this._updateHiddenIndices();\n this._plugins.invalidate();\n if (this.notifyPlugins('beforeUpdate', {mode, cancelable: true}) === false) {\n return;\n }\n const newControllers = this.buildOrUpdateControllers();\n this.notifyPlugins('beforeElementsUpdate');\n let minPadding = 0;\n for (let i = 0, ilen = this.data.datasets.length; i < ilen; i++) {\n const {controller} = this.getDatasetMeta(i);\n const reset = !animsDisabled && newControllers.indexOf(controller) === -1;\n controller.buildOrUpdateElements(reset);\n minPadding = Math.max(+controller.getMaxOverflow(), minPadding);\n }\n minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0;\n this._updateLayout(minPadding);\n if (!animsDisabled) {\n each(newControllers, (controller) => {\n controller.reset();\n });\n }\n this._updateDatasets(mode);\n this.notifyPlugins('afterUpdate', {mode});\n this._layers.sort(compare2Level('z', '_idx'));\n const {_active, _lastEvent} = this;\n if (_lastEvent) {\n this._eventHandler(_lastEvent, true);\n } else if (_active.length) {\n this._updateHoverStyles(_active, _active, true);\n }\n this.render();\n }\n _updateScales() {\n each(this.scales, (scale) => {\n layouts.removeBox(this, scale);\n });\n this.ensureScalesHaveIDs();\n this.buildOrUpdateScales();\n }\n _checkEventBindings() {\n const options = this.options;\n const existingEvents = new Set(Object.keys(this._listeners));\n const newEvents = new Set(options.events);\n if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {\n this.unbindEvents();\n this.bindEvents();\n }\n }\n _updateHiddenIndices() {\n const {_hiddenIndices} = this;\n const changes = this._getUniformDataChanges() || [];\n for (const {method, start, count} of changes) {\n const move = method === '_removeElements' ? -count : count;\n moveNumericKeys(_hiddenIndices, start, move);\n }\n }\n _getUniformDataChanges() {\n const _dataChanges = this._dataChanges;\n if (!_dataChanges || !_dataChanges.length) {\n return;\n }\n this._dataChanges = [];\n const datasetCount = this.data.datasets.length;\n const makeSet = (idx) => new Set(\n _dataChanges\n .filter(c => c[0] === idx)\n .map((c, i) => i + ',' + c.splice(1).join(','))\n );\n const changeSet = makeSet(0);\n for (let i = 1; i < datasetCount; i++) {\n if (!setsEqual(changeSet, makeSet(i))) {\n return;\n }\n }\n return Array.from(changeSet)\n .map(c => c.split(','))\n .map(a => ({method: a[1], start: +a[2], count: +a[3]}));\n }\n _updateLayout(minPadding) {\n if (this.notifyPlugins('beforeLayout', {cancelable: true}) === false) {\n return;\n }\n layouts.update(this, this.width, this.height, minPadding);\n const area = this.chartArea;\n const noArea = area.width <= 0 || area.height <= 0;\n this._layers = [];\n each(this.boxes, (box) => {\n if (noArea && box.position === 'chartArea') {\n return;\n }\n if (box.configure) {\n box.configure();\n }\n this._layers.push(...box._layers());\n }, this);\n this._layers.forEach((item, index) => {\n item._idx = index;\n });\n this.notifyPlugins('afterLayout');\n }\n _updateDatasets(mode) {\n if (this.notifyPlugins('beforeDatasetsUpdate', {mode, cancelable: true}) === false) {\n return;\n }\n for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n this.getDatasetMeta(i).controller.configure();\n }\n for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n this._updateDataset(i, isFunction(mode) ? mode({datasetIndex: i}) : mode);\n }\n this.notifyPlugins('afterDatasetsUpdate', {mode});\n }\n _updateDataset(index, mode) {\n const meta = this.getDatasetMeta(index);\n const args = {meta, index, mode, cancelable: true};\n if (this.notifyPlugins('beforeDatasetUpdate', args) === false) {\n return;\n }\n meta.controller._update(mode);\n args.cancelable = false;\n this.notifyPlugins('afterDatasetUpdate', args);\n }\n render() {\n if (this.notifyPlugins('beforeRender', {cancelable: true}) === false) {\n return;\n }\n if (animator.has(this)) {\n if (this.attached && !animator.running(this)) {\n animator.start(this);\n }\n } else {\n this.draw();\n onAnimationsComplete({chart: this});\n }\n }\n draw() {\n let i;\n if (this._resizeBeforeDraw) {\n const {width, height} = this._resizeBeforeDraw;\n this._resize(width, height);\n this._resizeBeforeDraw = null;\n }\n this.clear();\n if (this.width <= 0 || this.height <= 0) {\n return;\n }\n if (this.notifyPlugins('beforeDraw', {cancelable: true}) === false) {\n return;\n }\n const layers = this._layers;\n for (i = 0; i < layers.length && layers[i].z <= 0; ++i) {\n layers[i].draw(this.chartArea);\n }\n this._drawDatasets();\n for (; i < layers.length; ++i) {\n layers[i].draw(this.chartArea);\n }\n this.notifyPlugins('afterDraw');\n }\n _getSortedDatasetMetas(filterVisible) {\n const metasets = this._sortedMetasets;\n const result = [];\n let i, ilen;\n for (i = 0, ilen = metasets.length; i < ilen; ++i) {\n const meta = metasets[i];\n if (!filterVisible || meta.visible) {\n result.push(meta);\n }\n }\n return result;\n }\n getSortedVisibleDatasetMetas() {\n return this._getSortedDatasetMetas(true);\n }\n _drawDatasets() {\n if (this.notifyPlugins('beforeDatasetsDraw', {cancelable: true}) === false) {\n return;\n }\n const metasets = this.getSortedVisibleDatasetMetas();\n for (let i = metasets.length - 1; i >= 0; --i) {\n this._drawDataset(metasets[i]);\n }\n this.notifyPlugins('afterDatasetsDraw');\n }\n _drawDataset(meta) {\n const ctx = this.ctx;\n const clip = meta._clip;\n const useClip = !clip.disabled;\n const area = this.chartArea;\n const args = {\n meta,\n index: meta.index,\n cancelable: true\n };\n if (this.notifyPlugins('beforeDatasetDraw', args) === false) {\n return;\n }\n if (useClip) {\n clipArea(ctx, {\n left: clip.left === false ? 0 : area.left - clip.left,\n right: clip.right === false ? this.width : area.right + clip.right,\n top: clip.top === false ? 0 : area.top - clip.top,\n bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom\n });\n }\n meta.controller.draw();\n if (useClip) {\n unclipArea(ctx);\n }\n args.cancelable = false;\n this.notifyPlugins('afterDatasetDraw', args);\n }\n isPointInArea(point) {\n return _isPointInArea(point, this.chartArea, this._minPadding);\n }\n getElementsAtEventForMode(e, mode, options, useFinalPosition) {\n const method = Interaction.modes[mode];\n if (typeof method === 'function') {\n return method(this, e, options, useFinalPosition);\n }\n return [];\n }\n getDatasetMeta(datasetIndex) {\n const dataset = this.data.datasets[datasetIndex];\n const metasets = this._metasets;\n let meta = metasets.filter(x => x && x._dataset === dataset).pop();\n if (!meta) {\n meta = {\n type: null,\n data: [],\n dataset: null,\n controller: null,\n hidden: null,\n xAxisID: null,\n yAxisID: null,\n order: dataset && dataset.order || 0,\n index: datasetIndex,\n _dataset: dataset,\n _parsed: [],\n _sorted: false\n };\n metasets.push(meta);\n }\n return meta;\n }\n getContext() {\n return this.$context || (this.$context = createContext(null, {chart: this, type: 'chart'}));\n }\n getVisibleDatasetCount() {\n return this.getSortedVisibleDatasetMetas().length;\n }\n isDatasetVisible(datasetIndex) {\n const dataset = this.data.datasets[datasetIndex];\n if (!dataset) {\n return false;\n }\n const meta = this.getDatasetMeta(datasetIndex);\n return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden;\n }\n setDatasetVisibility(datasetIndex, visible) {\n const meta = this.getDatasetMeta(datasetIndex);\n meta.hidden = !visible;\n }\n toggleDataVisibility(index) {\n this._hiddenIndices[index] = !this._hiddenIndices[index];\n }\n getDataVisibility(index) {\n return !this._hiddenIndices[index];\n }\n _updateVisibility(datasetIndex, dataIndex, visible) {\n const mode = visible ? 'show' : 'hide';\n const meta = this.getDatasetMeta(datasetIndex);\n const anims = meta.controller._resolveAnimations(undefined, mode);\n if (defined(dataIndex)) {\n meta.data[dataIndex].hidden = !visible;\n this.update();\n } else {\n this.setDatasetVisibility(datasetIndex, visible);\n anims.update(meta, {visible});\n this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : undefined);\n }\n }\n hide(datasetIndex, dataIndex) {\n this._updateVisibility(datasetIndex, dataIndex, false);\n }\n show(datasetIndex, dataIndex) {\n this._updateVisibility(datasetIndex, dataIndex, true);\n }\n _destroyDatasetMeta(datasetIndex) {\n const meta = this._metasets[datasetIndex];\n if (meta && meta.controller) {\n meta.controller._destroy();\n }\n delete this._metasets[datasetIndex];\n }\n _stop() {\n let i, ilen;\n this.stop();\n animator.remove(this);\n for (i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {\n this._destroyDatasetMeta(i);\n }\n }\n destroy() {\n this.notifyPlugins('beforeDestroy');\n const {canvas, ctx} = this;\n this._stop();\n this.config.clearCache();\n if (canvas) {\n this.unbindEvents();\n clearCanvas(canvas, ctx);\n this.platform.releaseContext(ctx);\n this.canvas = null;\n this.ctx = null;\n }\n this.notifyPlugins('destroy');\n delete instances[this.id];\n this.notifyPlugins('afterDestroy');\n }\n toBase64Image(...args) {\n return this.canvas.toDataURL(...args);\n }\n bindEvents() {\n this.bindUserEvents();\n if (this.options.responsive) {\n this.bindResponsiveEvents();\n } else {\n this.attached = true;\n }\n }\n bindUserEvents() {\n const listeners = this._listeners;\n const platform = this.platform;\n const _add = (type, listener) => {\n platform.addEventListener(this, type, listener);\n listeners[type] = listener;\n };\n const listener = (e, x, y) => {\n e.offsetX = x;\n e.offsetY = y;\n this._eventHandler(e);\n };\n each(this.options.events, (type) => _add(type, listener));\n }\n bindResponsiveEvents() {\n if (!this._responsiveListeners) {\n this._responsiveListeners = {};\n }\n const listeners = this._responsiveListeners;\n const platform = this.platform;\n const _add = (type, listener) => {\n platform.addEventListener(this, type, listener);\n listeners[type] = listener;\n };\n const _remove = (type, listener) => {\n if (listeners[type]) {\n platform.removeEventListener(this, type, listener);\n delete listeners[type];\n }\n };\n const listener = (width, height) => {\n if (this.canvas) {\n this.resize(width, height);\n }\n };\n let detached;\n const attached = () => {\n _remove('attach', attached);\n this.attached = true;\n this.resize();\n _add('resize', listener);\n _add('detach', detached);\n };\n detached = () => {\n this.attached = false;\n _remove('resize', listener);\n this._stop();\n this._resize(0, 0);\n _add('attach', attached);\n };\n if (platform.isAttached(this.canvas)) {\n attached();\n } else {\n detached();\n }\n }\n unbindEvents() {\n each(this._listeners, (listener, type) => {\n this.platform.removeEventListener(this, type, listener);\n });\n this._listeners = {};\n each(this._responsiveListeners, (listener, type) => {\n this.platform.removeEventListener(this, type, listener);\n });\n this._responsiveListeners = undefined;\n }\n updateHoverStyle(items, mode, enabled) {\n const prefix = enabled ? 'set' : 'remove';\n let meta, item, i, ilen;\n if (mode === 'dataset') {\n meta = this.getDatasetMeta(items[0].datasetIndex);\n meta.controller['_' + prefix + 'DatasetHoverStyle']();\n }\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n item = items[i];\n const controller = item && this.getDatasetMeta(item.datasetIndex).controller;\n if (controller) {\n controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index);\n }\n }\n }\n getActiveElements() {\n return this._active || [];\n }\n setActiveElements(activeElements) {\n const lastActive = this._active || [];\n const active = activeElements.map(({datasetIndex, index}) => {\n const meta = this.getDatasetMeta(datasetIndex);\n if (!meta) {\n throw new Error('No dataset found at index ' + datasetIndex);\n }\n return {\n datasetIndex,\n element: meta.data[index],\n index,\n };\n });\n const changed = !_elementsEqual(active, lastActive);\n if (changed) {\n this._active = active;\n this._lastEvent = null;\n this._updateHoverStyles(active, lastActive);\n }\n }\n notifyPlugins(hook, args, filter) {\n return this._plugins.notify(this, hook, args, filter);\n }\n _updateHoverStyles(active, lastActive, replay) {\n const hoverOptions = this.options.hover;\n const diff = (a, b) => a.filter(x => !b.some(y => x.datasetIndex === y.datasetIndex && x.index === y.index));\n const deactivated = diff(lastActive, active);\n const activated = replay ? active : diff(active, lastActive);\n if (deactivated.length) {\n this.updateHoverStyle(deactivated, hoverOptions.mode, false);\n }\n if (activated.length && hoverOptions.mode) {\n this.updateHoverStyle(activated, hoverOptions.mode, true);\n }\n }\n _eventHandler(e, replay) {\n const args = {\n event: e,\n replay,\n cancelable: true,\n inChartArea: this.isPointInArea(e)\n };\n const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type);\n if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) {\n return;\n }\n const changed = this._handleEvent(e, replay, args.inChartArea);\n args.cancelable = false;\n this.notifyPlugins('afterEvent', args, eventFilter);\n if (changed || args.changed) {\n this.render();\n }\n return this;\n }\n _handleEvent(e, replay, inChartArea) {\n const {_active: lastActive = [], options} = this;\n const useFinalPosition = replay;\n const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition);\n const isClick = _isClickEvent(e);\n const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick);\n if (inChartArea) {\n this._lastEvent = null;\n callback(options.onHover, [e, active, this], this);\n if (isClick) {\n callback(options.onClick, [e, active, this], this);\n }\n }\n const changed = !_elementsEqual(active, lastActive);\n if (changed || replay) {\n this._active = active;\n this._updateHoverStyles(active, lastActive, replay);\n }\n this._lastEvent = lastEvent;\n return changed;\n }\n _getActiveElements(e, lastActive, inChartArea, useFinalPosition) {\n if (e.type === 'mouseout') {\n return [];\n }\n if (!inChartArea) {\n return lastActive;\n }\n const hoverOptions = this.options.hover;\n return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);\n }\n}\nconst invalidatePlugins = () => each(Chart.instances, (chart) => chart._plugins.invalidate());\nconst enumerable = true;\nObject.defineProperties(Chart, {\n defaults: {\n enumerable,\n value: defaults\n },\n instances: {\n enumerable,\n value: instances\n },\n overrides: {\n enumerable,\n value: overrides\n },\n registry: {\n enumerable,\n value: registry\n },\n version: {\n enumerable,\n value: version\n },\n getChart: {\n enumerable,\n value: getChart\n },\n register: {\n enumerable,\n value: (...items) => {\n registry.add(...items);\n invalidatePlugins();\n }\n },\n unregister: {\n enumerable,\n value: (...items) => {\n registry.remove(...items);\n invalidatePlugins();\n }\n }\n});\n\nfunction clipArc(ctx, element, endAngle) {\n const {startAngle, pixelMargin, x, y, outerRadius, innerRadius} = element;\n let angleMargin = pixelMargin / outerRadius;\n ctx.beginPath();\n ctx.arc(x, y, outerRadius, startAngle - angleMargin, endAngle + angleMargin);\n if (innerRadius > pixelMargin) {\n angleMargin = pixelMargin / innerRadius;\n ctx.arc(x, y, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true);\n } else {\n ctx.arc(x, y, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI);\n }\n ctx.closePath();\n ctx.clip();\n}\nfunction toRadiusCorners(value) {\n return _readValueToProps(value, ['outerStart', 'outerEnd', 'innerStart', 'innerEnd']);\n}\nfunction parseBorderRadius$1(arc, innerRadius, outerRadius, angleDelta) {\n const o = toRadiusCorners(arc.options.borderRadius);\n const halfThickness = (outerRadius - innerRadius) / 2;\n const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2);\n const computeOuterLimit = (val) => {\n const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2;\n return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit));\n };\n return {\n outerStart: computeOuterLimit(o.outerStart),\n outerEnd: computeOuterLimit(o.outerEnd),\n innerStart: _limitValue(o.innerStart, 0, innerLimit),\n innerEnd: _limitValue(o.innerEnd, 0, innerLimit),\n };\n}\nfunction rThetaToXY(r, theta, x, y) {\n return {\n x: x + r * Math.cos(theta),\n y: y + r * Math.sin(theta),\n };\n}\nfunction pathArc(ctx, element, offset, spacing, end) {\n const {x, y, startAngle: start, pixelMargin, innerRadius: innerR} = element;\n const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0);\n const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0;\n let spacingOffset = 0;\n const alpha = end - start;\n if (spacing) {\n const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0;\n const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0;\n const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2;\n const adjustedAngle = avNogSpacingRadius !== 0 ? (alpha * avNogSpacingRadius) / (avNogSpacingRadius + spacing) : alpha;\n spacingOffset = (alpha - adjustedAngle) / 2;\n }\n const beta = Math.max(0.001, alpha * outerRadius - offset / PI) / outerRadius;\n const angleOffset = (alpha - beta) / 2;\n const startAngle = start + angleOffset + spacingOffset;\n const endAngle = end - angleOffset - spacingOffset;\n const {outerStart, outerEnd, innerStart, innerEnd} = parseBorderRadius$1(element, innerRadius, outerRadius, endAngle - startAngle);\n const outerStartAdjustedRadius = outerRadius - outerStart;\n const outerEndAdjustedRadius = outerRadius - outerEnd;\n const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius;\n const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius;\n const innerStartAdjustedRadius = innerRadius + innerStart;\n const innerEndAdjustedRadius = innerRadius + innerEnd;\n const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius;\n const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius;\n ctx.beginPath();\n ctx.arc(x, y, outerRadius, outerStartAdjustedAngle, outerEndAdjustedAngle);\n if (outerEnd > 0) {\n const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x, y);\n ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI);\n }\n const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x, y);\n ctx.lineTo(p4.x, p4.y);\n if (innerEnd > 0) {\n const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x, y);\n ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI);\n }\n ctx.arc(x, y, innerRadius, endAngle - (innerEnd / innerRadius), startAngle + (innerStart / innerRadius), true);\n if (innerStart > 0) {\n const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x, y);\n ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI);\n }\n const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x, y);\n ctx.lineTo(p8.x, p8.y);\n if (outerStart > 0) {\n const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x, y);\n ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle);\n }\n ctx.closePath();\n}\nfunction drawArc(ctx, element, offset, spacing) {\n const {fullCircles, startAngle, circumference} = element;\n let endAngle = element.endAngle;\n if (fullCircles) {\n pathArc(ctx, element, offset, spacing, startAngle + TAU);\n for (let i = 0; i < fullCircles; ++i) {\n ctx.fill();\n }\n if (!isNaN(circumference)) {\n endAngle = startAngle + circumference % TAU;\n if (circumference % TAU === 0) {\n endAngle += TAU;\n }\n }\n }\n pathArc(ctx, element, offset, spacing, endAngle);\n ctx.fill();\n return endAngle;\n}\nfunction drawFullCircleBorders(ctx, element, inner) {\n const {x, y, startAngle, pixelMargin, fullCircles} = element;\n const outerRadius = Math.max(element.outerRadius - pixelMargin, 0);\n const innerRadius = element.innerRadius + pixelMargin;\n let i;\n if (inner) {\n clipArc(ctx, element, startAngle + TAU);\n }\n ctx.beginPath();\n ctx.arc(x, y, innerRadius, startAngle + TAU, startAngle, true);\n for (i = 0; i < fullCircles; ++i) {\n ctx.stroke();\n }\n ctx.beginPath();\n ctx.arc(x, y, outerRadius, startAngle, startAngle + TAU);\n for (i = 0; i < fullCircles; ++i) {\n ctx.stroke();\n }\n}\nfunction drawBorder(ctx, element, offset, spacing, endAngle) {\n const {options} = element;\n const {borderWidth, borderJoinStyle} = options;\n const inner = options.borderAlign === 'inner';\n if (!borderWidth) {\n return;\n }\n if (inner) {\n ctx.lineWidth = borderWidth * 2;\n ctx.lineJoin = borderJoinStyle || 'round';\n } else {\n ctx.lineWidth = borderWidth;\n ctx.lineJoin = borderJoinStyle || 'bevel';\n }\n if (element.fullCircles) {\n drawFullCircleBorders(ctx, element, inner);\n }\n if (inner) {\n clipArc(ctx, element, endAngle);\n }\n pathArc(ctx, element, offset, spacing, endAngle);\n ctx.stroke();\n}\nclass ArcElement extends Element {\n constructor(cfg) {\n super();\n this.options = undefined;\n this.circumference = undefined;\n this.startAngle = undefined;\n this.endAngle = undefined;\n this.innerRadius = undefined;\n this.outerRadius = undefined;\n this.pixelMargin = 0;\n this.fullCircles = 0;\n if (cfg) {\n Object.assign(this, cfg);\n }\n }\n inRange(chartX, chartY, useFinalPosition) {\n const point = this.getProps(['x', 'y'], useFinalPosition);\n const {angle, distance} = getAngleFromPoint(point, {x: chartX, y: chartY});\n const {startAngle, endAngle, innerRadius, outerRadius, circumference} = this.getProps([\n 'startAngle',\n 'endAngle',\n 'innerRadius',\n 'outerRadius',\n 'circumference'\n ], useFinalPosition);\n const rAdjust = this.options.spacing / 2;\n const _circumference = valueOrDefault(circumference, endAngle - startAngle);\n const betweenAngles = _circumference >= TAU || _angleBetween(angle, startAngle, endAngle);\n const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust);\n return (betweenAngles && withinRadius);\n }\n getCenterPoint(useFinalPosition) {\n const {x, y, startAngle, endAngle, innerRadius, outerRadius} = this.getProps([\n 'x',\n 'y',\n 'startAngle',\n 'endAngle',\n 'innerRadius',\n 'outerRadius',\n 'circumference',\n ], useFinalPosition);\n const {offset, spacing} = this.options;\n const halfAngle = (startAngle + endAngle) / 2;\n const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2;\n return {\n x: x + Math.cos(halfAngle) * halfRadius,\n y: y + Math.sin(halfAngle) * halfRadius\n };\n }\n tooltipPosition(useFinalPosition) {\n return this.getCenterPoint(useFinalPosition);\n }\n draw(ctx) {\n const {options, circumference} = this;\n const offset = (options.offset || 0) / 2;\n const spacing = (options.spacing || 0) / 2;\n this.pixelMargin = (options.borderAlign === 'inner') ? 0.33 : 0;\n this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0;\n if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) {\n return;\n }\n ctx.save();\n let radiusOffset = 0;\n if (offset) {\n radiusOffset = offset / 2;\n const halfAngle = (this.startAngle + this.endAngle) / 2;\n ctx.translate(Math.cos(halfAngle) * radiusOffset, Math.sin(halfAngle) * radiusOffset);\n if (this.circumference >= PI) {\n radiusOffset = offset;\n }\n }\n ctx.fillStyle = options.backgroundColor;\n ctx.strokeStyle = options.borderColor;\n const endAngle = drawArc(ctx, this, radiusOffset, spacing);\n drawBorder(ctx, this, radiusOffset, spacing, endAngle);\n ctx.restore();\n }\n}\nArcElement.id = 'arc';\nArcElement.defaults = {\n borderAlign: 'center',\n borderColor: '#fff',\n borderJoinStyle: undefined,\n borderRadius: 0,\n borderWidth: 2,\n offset: 0,\n spacing: 0,\n angle: undefined,\n};\nArcElement.defaultRoutes = {\n backgroundColor: 'backgroundColor'\n};\n\nfunction setStyle(ctx, options, style = options) {\n ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle);\n ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash));\n ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset);\n ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle);\n ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth);\n ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor);\n}\nfunction lineTo(ctx, previous, target) {\n ctx.lineTo(target.x, target.y);\n}\nfunction getLineMethod(options) {\n if (options.stepped) {\n return _steppedLineTo;\n }\n if (options.tension || options.cubicInterpolationMode === 'monotone') {\n return _bezierCurveTo;\n }\n return lineTo;\n}\nfunction pathVars(points, segment, params = {}) {\n const count = points.length;\n const {start: paramsStart = 0, end: paramsEnd = count - 1} = params;\n const {start: segmentStart, end: segmentEnd} = segment;\n const start = Math.max(paramsStart, segmentStart);\n const end = Math.min(paramsEnd, segmentEnd);\n const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd;\n return {\n count,\n start,\n loop: segment.loop,\n ilen: end < start && !outside ? count + end - start : end - start\n };\n}\nfunction pathSegment(ctx, line, segment, params) {\n const {points, options} = line;\n const {count, start, loop, ilen} = pathVars(points, segment, params);\n const lineMethod = getLineMethod(options);\n let {move = true, reverse} = params || {};\n let i, point, prev;\n for (i = 0; i <= ilen; ++i) {\n point = points[(start + (reverse ? ilen - i : i)) % count];\n if (point.skip) {\n continue;\n } else if (move) {\n ctx.moveTo(point.x, point.y);\n move = false;\n } else {\n lineMethod(ctx, prev, point, reverse, options.stepped);\n }\n prev = point;\n }\n if (loop) {\n point = points[(start + (reverse ? ilen : 0)) % count];\n lineMethod(ctx, prev, point, reverse, options.stepped);\n }\n return !!loop;\n}\nfunction fastPathSegment(ctx, line, segment, params) {\n const points = line.points;\n const {count, start, ilen} = pathVars(points, segment, params);\n const {move = true, reverse} = params || {};\n let avgX = 0;\n let countX = 0;\n let i, point, prevX, minY, maxY, lastY;\n const pointIndex = (index) => (start + (reverse ? ilen - index : index)) % count;\n const drawX = () => {\n if (minY !== maxY) {\n ctx.lineTo(avgX, maxY);\n ctx.lineTo(avgX, minY);\n ctx.lineTo(avgX, lastY);\n }\n };\n if (move) {\n point = points[pointIndex(0)];\n ctx.moveTo(point.x, point.y);\n }\n for (i = 0; i <= ilen; ++i) {\n point = points[pointIndex(i)];\n if (point.skip) {\n continue;\n }\n const x = point.x;\n const y = point.y;\n const truncX = x | 0;\n if (truncX === prevX) {\n if (y < minY) {\n minY = y;\n } else if (y > maxY) {\n maxY = y;\n }\n avgX = (countX * avgX + x) / ++countX;\n } else {\n drawX();\n ctx.lineTo(x, y);\n prevX = truncX;\n countX = 0;\n minY = maxY = y;\n }\n lastY = y;\n }\n drawX();\n}\nfunction _getSegmentMethod(line) {\n const opts = line.options;\n const borderDash = opts.borderDash && opts.borderDash.length;\n const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== 'monotone' && !opts.stepped && !borderDash;\n return useFastPath ? fastPathSegment : pathSegment;\n}\nfunction _getInterpolationMethod(options) {\n if (options.stepped) {\n return _steppedInterpolation;\n }\n if (options.tension || options.cubicInterpolationMode === 'monotone') {\n return _bezierInterpolation;\n }\n return _pointInLine;\n}\nfunction strokePathWithCache(ctx, line, start, count) {\n let path = line._path;\n if (!path) {\n path = line._path = new Path2D();\n if (line.path(path, start, count)) {\n path.closePath();\n }\n }\n setStyle(ctx, line.options);\n ctx.stroke(path);\n}\nfunction strokePathDirect(ctx, line, start, count) {\n const {segments, options} = line;\n const segmentMethod = _getSegmentMethod(line);\n for (const segment of segments) {\n setStyle(ctx, options, segment.style);\n ctx.beginPath();\n if (segmentMethod(ctx, line, segment, {start, end: start + count - 1})) {\n ctx.closePath();\n }\n ctx.stroke();\n }\n}\nconst usePath2D = typeof Path2D === 'function';\nfunction draw(ctx, line, start, count) {\n if (usePath2D && !line.options.segment) {\n strokePathWithCache(ctx, line, start, count);\n } else {\n strokePathDirect(ctx, line, start, count);\n }\n}\nclass LineElement extends Element {\n constructor(cfg) {\n super();\n this.animated = true;\n this.options = undefined;\n this._chart = undefined;\n this._loop = undefined;\n this._fullLoop = undefined;\n this._path = undefined;\n this._points = undefined;\n this._segments = undefined;\n this._decimated = false;\n this._pointsUpdated = false;\n this._datasetIndex = undefined;\n if (cfg) {\n Object.assign(this, cfg);\n }\n }\n updateControlPoints(chartArea, indexAxis) {\n const options = this.options;\n if ((options.tension || options.cubicInterpolationMode === 'monotone') && !options.stepped && !this._pointsUpdated) {\n const loop = options.spanGaps ? this._loop : this._fullLoop;\n _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis);\n this._pointsUpdated = true;\n }\n }\n set points(points) {\n this._points = points;\n delete this._segments;\n delete this._path;\n this._pointsUpdated = false;\n }\n get points() {\n return this._points;\n }\n get segments() {\n return this._segments || (this._segments = _computeSegments(this, this.options.segment));\n }\n first() {\n const segments = this.segments;\n const points = this.points;\n return segments.length && points[segments[0].start];\n }\n last() {\n const segments = this.segments;\n const points = this.points;\n const count = segments.length;\n return count && points[segments[count - 1].end];\n }\n interpolate(point, property) {\n const options = this.options;\n const value = point[property];\n const points = this.points;\n const segments = _boundSegments(this, {property, start: value, end: value});\n if (!segments.length) {\n return;\n }\n const result = [];\n const _interpolate = _getInterpolationMethod(options);\n let i, ilen;\n for (i = 0, ilen = segments.length; i < ilen; ++i) {\n const {start, end} = segments[i];\n const p1 = points[start];\n const p2 = points[end];\n if (p1 === p2) {\n result.push(p1);\n continue;\n }\n const t = Math.abs((value - p1[property]) / (p2[property] - p1[property]));\n const interpolated = _interpolate(p1, p2, t, options.stepped);\n interpolated[property] = point[property];\n result.push(interpolated);\n }\n return result.length === 1 ? result[0] : result;\n }\n pathSegment(ctx, segment, params) {\n const segmentMethod = _getSegmentMethod(this);\n return segmentMethod(ctx, this, segment, params);\n }\n path(ctx, start, count) {\n const segments = this.segments;\n const segmentMethod = _getSegmentMethod(this);\n let loop = this._loop;\n start = start || 0;\n count = count || (this.points.length - start);\n for (const segment of segments) {\n loop &= segmentMethod(ctx, this, segment, {start, end: start + count - 1});\n }\n return !!loop;\n }\n draw(ctx, chartArea, start, count) {\n const options = this.options || {};\n const points = this.points || [];\n if (points.length && options.borderWidth) {\n ctx.save();\n draw(ctx, this, start, count);\n ctx.restore();\n }\n if (this.animated) {\n this._pointsUpdated = false;\n this._path = undefined;\n }\n }\n}\nLineElement.id = 'line';\nLineElement.defaults = {\n borderCapStyle: 'butt',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderWidth: 3,\n capBezierPoints: true,\n cubicInterpolationMode: 'default',\n fill: false,\n spanGaps: false,\n stepped: false,\n tension: 0,\n};\nLineElement.defaultRoutes = {\n backgroundColor: 'backgroundColor',\n borderColor: 'borderColor'\n};\nLineElement.descriptors = {\n _scriptable: true,\n _indexable: (name) => name !== 'borderDash' && name !== 'fill',\n};\n\nfunction inRange$1(el, pos, axis, useFinalPosition) {\n const options = el.options;\n const {[axis]: value} = el.getProps([axis], useFinalPosition);\n return (Math.abs(pos - value) < options.radius + options.hitRadius);\n}\nclass PointElement extends Element {\n constructor(cfg) {\n super();\n this.options = undefined;\n this.parsed = undefined;\n this.skip = undefined;\n this.stop = undefined;\n if (cfg) {\n Object.assign(this, cfg);\n }\n }\n inRange(mouseX, mouseY, useFinalPosition) {\n const options = this.options;\n const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n return ((Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2)) < Math.pow(options.hitRadius + options.radius, 2));\n }\n inXRange(mouseX, useFinalPosition) {\n return inRange$1(this, mouseX, 'x', useFinalPosition);\n }\n inYRange(mouseY, useFinalPosition) {\n return inRange$1(this, mouseY, 'y', useFinalPosition);\n }\n getCenterPoint(useFinalPosition) {\n const {x, y} = this.getProps(['x', 'y'], useFinalPosition);\n return {x, y};\n }\n size(options) {\n options = options || this.options || {};\n let radius = options.radius || 0;\n radius = Math.max(radius, radius && options.hoverRadius || 0);\n const borderWidth = radius && options.borderWidth || 0;\n return (radius + borderWidth) * 2;\n }\n draw(ctx, area) {\n const options = this.options;\n if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) {\n return;\n }\n ctx.strokeStyle = options.borderColor;\n ctx.lineWidth = options.borderWidth;\n ctx.fillStyle = options.backgroundColor;\n drawPoint(ctx, options, this.x, this.y);\n }\n getRange() {\n const options = this.options || {};\n return options.radius + options.hitRadius;\n }\n}\nPointElement.id = 'point';\nPointElement.defaults = {\n borderWidth: 1,\n hitRadius: 1,\n hoverBorderWidth: 1,\n hoverRadius: 4,\n pointStyle: 'circle',\n radius: 3,\n rotation: 0\n};\nPointElement.defaultRoutes = {\n backgroundColor: 'backgroundColor',\n borderColor: 'borderColor'\n};\n\nfunction getBarBounds(bar, useFinalPosition) {\n const {x, y, base, width, height} = bar.getProps(['x', 'y', 'base', 'width', 'height'], useFinalPosition);\n let left, right, top, bottom, half;\n if (bar.horizontal) {\n half = height / 2;\n left = Math.min(x, base);\n right = Math.max(x, base);\n top = y - half;\n bottom = y + half;\n } else {\n half = width / 2;\n left = x - half;\n right = x + half;\n top = Math.min(y, base);\n bottom = Math.max(y, base);\n }\n return {left, top, right, bottom};\n}\nfunction skipOrLimit(skip, value, min, max) {\n return skip ? 0 : _limitValue(value, min, max);\n}\nfunction parseBorderWidth(bar, maxW, maxH) {\n const value = bar.options.borderWidth;\n const skip = bar.borderSkipped;\n const o = toTRBL(value);\n return {\n t: skipOrLimit(skip.top, o.top, 0, maxH),\n r: skipOrLimit(skip.right, o.right, 0, maxW),\n b: skipOrLimit(skip.bottom, o.bottom, 0, maxH),\n l: skipOrLimit(skip.left, o.left, 0, maxW)\n };\n}\nfunction parseBorderRadius(bar, maxW, maxH) {\n const {enableBorderRadius} = bar.getProps(['enableBorderRadius']);\n const value = bar.options.borderRadius;\n const o = toTRBLCorners(value);\n const maxR = Math.min(maxW, maxH);\n const skip = bar.borderSkipped;\n const enableBorder = enableBorderRadius || isObject(value);\n return {\n topLeft: skipOrLimit(!enableBorder || skip.top || skip.left, o.topLeft, 0, maxR),\n topRight: skipOrLimit(!enableBorder || skip.top || skip.right, o.topRight, 0, maxR),\n bottomLeft: skipOrLimit(!enableBorder || skip.bottom || skip.left, o.bottomLeft, 0, maxR),\n bottomRight: skipOrLimit(!enableBorder || skip.bottom || skip.right, o.bottomRight, 0, maxR)\n };\n}\nfunction boundingRects(bar) {\n const bounds = getBarBounds(bar);\n const width = bounds.right - bounds.left;\n const height = bounds.bottom - bounds.top;\n const border = parseBorderWidth(bar, width / 2, height / 2);\n const radius = parseBorderRadius(bar, width / 2, height / 2);\n return {\n outer: {\n x: bounds.left,\n y: bounds.top,\n w: width,\n h: height,\n radius\n },\n inner: {\n x: bounds.left + border.l,\n y: bounds.top + border.t,\n w: width - border.l - border.r,\n h: height - border.t - border.b,\n radius: {\n topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)),\n topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)),\n bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)),\n bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r)),\n }\n }\n };\n}\nfunction inRange(bar, x, y, useFinalPosition) {\n const skipX = x === null;\n const skipY = y === null;\n const skipBoth = skipX && skipY;\n const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);\n return bounds\n\t\t&& (skipX || _isBetween(x, bounds.left, bounds.right))\n\t\t&& (skipY || _isBetween(y, bounds.top, bounds.bottom));\n}\nfunction hasRadius(radius) {\n return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;\n}\nfunction addNormalRectPath(ctx, rect) {\n ctx.rect(rect.x, rect.y, rect.w, rect.h);\n}\nfunction inflateRect(rect, amount, refRect = {}) {\n const x = rect.x !== refRect.x ? -amount : 0;\n const y = rect.y !== refRect.y ? -amount : 0;\n const w = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x;\n const h = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y;\n return {\n x: rect.x + x,\n y: rect.y + y,\n w: rect.w + w,\n h: rect.h + h,\n radius: rect.radius\n };\n}\nclass BarElement extends Element {\n constructor(cfg) {\n super();\n this.options = undefined;\n this.horizontal = undefined;\n this.base = undefined;\n this.width = undefined;\n this.height = undefined;\n this.inflateAmount = undefined;\n if (cfg) {\n Object.assign(this, cfg);\n }\n }\n draw(ctx) {\n const {inflateAmount, options: {borderColor, backgroundColor}} = this;\n const {inner, outer} = boundingRects(this);\n const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath;\n ctx.save();\n if (outer.w !== inner.w || outer.h !== inner.h) {\n ctx.beginPath();\n addRectPath(ctx, inflateRect(outer, inflateAmount, inner));\n ctx.clip();\n addRectPath(ctx, inflateRect(inner, -inflateAmount, outer));\n ctx.fillStyle = borderColor;\n ctx.fill('evenodd');\n }\n ctx.beginPath();\n addRectPath(ctx, inflateRect(inner, inflateAmount));\n ctx.fillStyle = backgroundColor;\n ctx.fill();\n ctx.restore();\n }\n inRange(mouseX, mouseY, useFinalPosition) {\n return inRange(this, mouseX, mouseY, useFinalPosition);\n }\n inXRange(mouseX, useFinalPosition) {\n return inRange(this, mouseX, null, useFinalPosition);\n }\n inYRange(mouseY, useFinalPosition) {\n return inRange(this, null, mouseY, useFinalPosition);\n }\n getCenterPoint(useFinalPosition) {\n const {x, y, base, horizontal} = this.getProps(['x', 'y', 'base', 'horizontal'], useFinalPosition);\n return {\n x: horizontal ? (x + base) / 2 : x,\n y: horizontal ? y : (y + base) / 2\n };\n }\n getRange(axis) {\n return axis === 'x' ? this.width / 2 : this.height / 2;\n }\n}\nBarElement.id = 'bar';\nBarElement.defaults = {\n borderSkipped: 'start',\n borderWidth: 0,\n borderRadius: 0,\n inflateAmount: 'auto',\n pointStyle: undefined\n};\nBarElement.defaultRoutes = {\n backgroundColor: 'backgroundColor',\n borderColor: 'borderColor'\n};\n\nvar elements = /*#__PURE__*/Object.freeze({\n__proto__: null,\nArcElement: ArcElement,\nLineElement: LineElement,\nPointElement: PointElement,\nBarElement: BarElement\n});\n\nfunction lttbDecimation(data, start, count, availableWidth, options) {\n const samples = options.samples || availableWidth;\n if (samples >= count) {\n return data.slice(start, start + count);\n }\n const decimated = [];\n const bucketWidth = (count - 2) / (samples - 2);\n let sampledIndex = 0;\n const endIndex = start + count - 1;\n let a = start;\n let i, maxAreaPoint, maxArea, area, nextA;\n decimated[sampledIndex++] = data[a];\n for (i = 0; i < samples - 2; i++) {\n let avgX = 0;\n let avgY = 0;\n let j;\n const avgRangeStart = Math.floor((i + 1) * bucketWidth) + 1 + start;\n const avgRangeEnd = Math.min(Math.floor((i + 2) * bucketWidth) + 1, count) + start;\n const avgRangeLength = avgRangeEnd - avgRangeStart;\n for (j = avgRangeStart; j < avgRangeEnd; j++) {\n avgX += data[j].x;\n avgY += data[j].y;\n }\n avgX /= avgRangeLength;\n avgY /= avgRangeLength;\n const rangeOffs = Math.floor(i * bucketWidth) + 1 + start;\n const rangeTo = Math.min(Math.floor((i + 1) * bucketWidth) + 1, count) + start;\n const {x: pointAx, y: pointAy} = data[a];\n maxArea = area = -1;\n for (j = rangeOffs; j < rangeTo; j++) {\n area = 0.5 * Math.abs(\n (pointAx - avgX) * (data[j].y - pointAy) -\n (pointAx - data[j].x) * (avgY - pointAy)\n );\n if (area > maxArea) {\n maxArea = area;\n maxAreaPoint = data[j];\n nextA = j;\n }\n }\n decimated[sampledIndex++] = maxAreaPoint;\n a = nextA;\n }\n decimated[sampledIndex++] = data[endIndex];\n return decimated;\n}\nfunction minMaxDecimation(data, start, count, availableWidth) {\n let avgX = 0;\n let countX = 0;\n let i, point, x, y, prevX, minIndex, maxIndex, startIndex, minY, maxY;\n const decimated = [];\n const endIndex = start + count - 1;\n const xMin = data[start].x;\n const xMax = data[endIndex].x;\n const dx = xMax - xMin;\n for (i = start; i < start + count; ++i) {\n point = data[i];\n x = (point.x - xMin) / dx * availableWidth;\n y = point.y;\n const truncX = x | 0;\n if (truncX === prevX) {\n if (y < minY) {\n minY = y;\n minIndex = i;\n } else if (y > maxY) {\n maxY = y;\n maxIndex = i;\n }\n avgX = (countX * avgX + point.x) / ++countX;\n } else {\n const lastIndex = i - 1;\n if (!isNullOrUndef(minIndex) && !isNullOrUndef(maxIndex)) {\n const intermediateIndex1 = Math.min(minIndex, maxIndex);\n const intermediateIndex2 = Math.max(minIndex, maxIndex);\n if (intermediateIndex1 !== startIndex && intermediateIndex1 !== lastIndex) {\n decimated.push({\n ...data[intermediateIndex1],\n x: avgX,\n });\n }\n if (intermediateIndex2 !== startIndex && intermediateIndex2 !== lastIndex) {\n decimated.push({\n ...data[intermediateIndex2],\n x: avgX\n });\n }\n }\n if (i > 0 && lastIndex !== startIndex) {\n decimated.push(data[lastIndex]);\n }\n decimated.push(point);\n prevX = truncX;\n countX = 0;\n minY = maxY = y;\n minIndex = maxIndex = startIndex = i;\n }\n }\n return decimated;\n}\nfunction cleanDecimatedDataset(dataset) {\n if (dataset._decimated) {\n const data = dataset._data;\n delete dataset._decimated;\n delete dataset._data;\n Object.defineProperty(dataset, 'data', {value: data});\n }\n}\nfunction cleanDecimatedData(chart) {\n chart.data.datasets.forEach((dataset) => {\n cleanDecimatedDataset(dataset);\n });\n}\nfunction getStartAndCountOfVisiblePointsSimplified(meta, points) {\n const pointCount = points.length;\n let start = 0;\n let count;\n const {iScale} = meta;\n const {min, max, minDefined, maxDefined} = iScale.getUserBounds();\n if (minDefined) {\n start = _limitValue(_lookupByKey(points, iScale.axis, min).lo, 0, pointCount - 1);\n }\n if (maxDefined) {\n count = _limitValue(_lookupByKey(points, iScale.axis, max).hi + 1, start, pointCount) - start;\n } else {\n count = pointCount - start;\n }\n return {start, count};\n}\nvar plugin_decimation = {\n id: 'decimation',\n defaults: {\n algorithm: 'min-max',\n enabled: false,\n },\n beforeElementsUpdate: (chart, args, options) => {\n if (!options.enabled) {\n cleanDecimatedData(chart);\n return;\n }\n const availableWidth = chart.width;\n chart.data.datasets.forEach((dataset, datasetIndex) => {\n const {_data, indexAxis} = dataset;\n const meta = chart.getDatasetMeta(datasetIndex);\n const data = _data || dataset.data;\n if (resolve([indexAxis, chart.options.indexAxis]) === 'y') {\n return;\n }\n if (!meta.controller.supportsDecimation) {\n return;\n }\n const xAxis = chart.scales[meta.xAxisID];\n if (xAxis.type !== 'linear' && xAxis.type !== 'time') {\n return;\n }\n if (chart.options.parsing) {\n return;\n }\n let {start, count} = getStartAndCountOfVisiblePointsSimplified(meta, data);\n const threshold = options.threshold || 4 * availableWidth;\n if (count <= threshold) {\n cleanDecimatedDataset(dataset);\n return;\n }\n if (isNullOrUndef(_data)) {\n dataset._data = data;\n delete dataset.data;\n Object.defineProperty(dataset, 'data', {\n configurable: true,\n enumerable: true,\n get: function() {\n return this._decimated;\n },\n set: function(d) {\n this._data = d;\n }\n });\n }\n let decimated;\n switch (options.algorithm) {\n case 'lttb':\n decimated = lttbDecimation(data, start, count, availableWidth, options);\n break;\n case 'min-max':\n decimated = minMaxDecimation(data, start, count, availableWidth);\n break;\n default:\n throw new Error(`Unsupported decimation algorithm '${options.algorithm}'`);\n }\n dataset._decimated = decimated;\n });\n },\n destroy(chart) {\n cleanDecimatedData(chart);\n }\n};\n\nfunction _segments(line, target, property) {\n const segments = line.segments;\n const points = line.points;\n const tpoints = target.points;\n const parts = [];\n for (const segment of segments) {\n let {start, end} = segment;\n end = _findSegmentEnd(start, end, points);\n const bounds = _getBounds(property, points[start], points[end], segment.loop);\n if (!target.segments) {\n parts.push({\n source: segment,\n target: bounds,\n start: points[start],\n end: points[end]\n });\n continue;\n }\n const targetSegments = _boundSegments(target, bounds);\n for (const tgt of targetSegments) {\n const subBounds = _getBounds(property, tpoints[tgt.start], tpoints[tgt.end], tgt.loop);\n const fillSources = _boundSegment(segment, points, subBounds);\n for (const fillSource of fillSources) {\n parts.push({\n source: fillSource,\n target: tgt,\n start: {\n [property]: _getEdge(bounds, subBounds, 'start', Math.max)\n },\n end: {\n [property]: _getEdge(bounds, subBounds, 'end', Math.min)\n }\n });\n }\n }\n }\n return parts;\n}\nfunction _getBounds(property, first, last, loop) {\n if (loop) {\n return;\n }\n let start = first[property];\n let end = last[property];\n if (property === 'angle') {\n start = _normalizeAngle(start);\n end = _normalizeAngle(end);\n }\n return {property, start, end};\n}\nfunction _pointsFromSegments(boundary, line) {\n const {x = null, y = null} = boundary || {};\n const linePoints = line.points;\n const points = [];\n line.segments.forEach(({start, end}) => {\n end = _findSegmentEnd(start, end, linePoints);\n const first = linePoints[start];\n const last = linePoints[end];\n if (y !== null) {\n points.push({x: first.x, y});\n points.push({x: last.x, y});\n } else if (x !== null) {\n points.push({x, y: first.y});\n points.push({x, y: last.y});\n }\n });\n return points;\n}\nfunction _findSegmentEnd(start, end, points) {\n for (;end > start; end--) {\n const point = points[end];\n if (!isNaN(point.x) && !isNaN(point.y)) {\n break;\n }\n }\n return end;\n}\nfunction _getEdge(a, b, prop, fn) {\n if (a && b) {\n return fn(a[prop], b[prop]);\n }\n return a ? a[prop] : b ? b[prop] : 0;\n}\n\nfunction _createBoundaryLine(boundary, line) {\n let points = [];\n let _loop = false;\n if (isArray(boundary)) {\n _loop = true;\n points = boundary;\n } else {\n points = _pointsFromSegments(boundary, line);\n }\n return points.length ? new LineElement({\n points,\n options: {tension: 0},\n _loop,\n _fullLoop: _loop\n }) : null;\n}\n\nfunction _resolveTarget(sources, index, propagate) {\n const source = sources[index];\n let fill = source.fill;\n const visited = [index];\n let target;\n if (!propagate) {\n return fill;\n }\n while (fill !== false && visited.indexOf(fill) === -1) {\n if (!isNumberFinite(fill)) {\n return fill;\n }\n target = sources[fill];\n if (!target) {\n return false;\n }\n if (target.visible) {\n return fill;\n }\n visited.push(fill);\n fill = target.fill;\n }\n return false;\n}\nfunction _decodeFill(line, index, count) {\n const fill = parseFillOption(line);\n if (isObject(fill)) {\n return isNaN(fill.value) ? false : fill;\n }\n let target = parseFloat(fill);\n if (isNumberFinite(target) && Math.floor(target) === target) {\n return decodeTargetIndex(fill[0], index, target, count);\n }\n return ['origin', 'start', 'end', 'stack', 'shape'].indexOf(fill) >= 0 && fill;\n}\nfunction decodeTargetIndex(firstCh, index, target, count) {\n if (firstCh === '-' || firstCh === '+') {\n target = index + target;\n }\n if (target === index || target < 0 || target >= count) {\n return false;\n }\n return target;\n}\nfunction _getTargetPixel(fill, scale) {\n let pixel = null;\n if (fill === 'start') {\n pixel = scale.bottom;\n } else if (fill === 'end') {\n pixel = scale.top;\n } else if (isObject(fill)) {\n pixel = scale.getPixelForValue(fill.value);\n } else if (scale.getBasePixel) {\n pixel = scale.getBasePixel();\n }\n return pixel;\n}\nfunction _getTargetValue(fill, scale, startValue) {\n let value;\n if (fill === 'start') {\n value = startValue;\n } else if (fill === 'end') {\n value = scale.options.reverse ? scale.min : scale.max;\n } else if (isObject(fill)) {\n value = fill.value;\n } else {\n value = scale.getBaseValue();\n }\n return value;\n}\nfunction parseFillOption(line) {\n const options = line.options;\n const fillOption = options.fill;\n let fill = valueOrDefault(fillOption && fillOption.target, fillOption);\n if (fill === undefined) {\n fill = !!options.backgroundColor;\n }\n if (fill === false || fill === null) {\n return false;\n }\n if (fill === true) {\n return 'origin';\n }\n return fill;\n}\n\nfunction _buildStackLine(source) {\n const {scale, index, line} = source;\n const points = [];\n const segments = line.segments;\n const sourcePoints = line.points;\n const linesBelow = getLinesBelow(scale, index);\n linesBelow.push(_createBoundaryLine({x: null, y: scale.bottom}, line));\n for (let i = 0; i < segments.length; i++) {\n const segment = segments[i];\n for (let j = segment.start; j <= segment.end; j++) {\n addPointsBelow(points, sourcePoints[j], linesBelow);\n }\n }\n return new LineElement({points, options: {}});\n}\nfunction getLinesBelow(scale, index) {\n const below = [];\n const metas = scale.getMatchingVisibleMetas('line');\n for (let i = 0; i < metas.length; i++) {\n const meta = metas[i];\n if (meta.index === index) {\n break;\n }\n if (!meta.hidden) {\n below.unshift(meta.dataset);\n }\n }\n return below;\n}\nfunction addPointsBelow(points, sourcePoint, linesBelow) {\n const postponed = [];\n for (let j = 0; j < linesBelow.length; j++) {\n const line = linesBelow[j];\n const {first, last, point} = findPoint(line, sourcePoint, 'x');\n if (!point || (first && last)) {\n continue;\n }\n if (first) {\n postponed.unshift(point);\n } else {\n points.push(point);\n if (!last) {\n break;\n }\n }\n }\n points.push(...postponed);\n}\nfunction findPoint(line, sourcePoint, property) {\n const point = line.interpolate(sourcePoint, property);\n if (!point) {\n return {};\n }\n const pointValue = point[property];\n const segments = line.segments;\n const linePoints = line.points;\n let first = false;\n let last = false;\n for (let i = 0; i < segments.length; i++) {\n const segment = segments[i];\n const firstValue = linePoints[segment.start][property];\n const lastValue = linePoints[segment.end][property];\n if (_isBetween(pointValue, firstValue, lastValue)) {\n first = pointValue === firstValue;\n last = pointValue === lastValue;\n break;\n }\n }\n return {first, last, point};\n}\n\nclass simpleArc {\n constructor(opts) {\n this.x = opts.x;\n this.y = opts.y;\n this.radius = opts.radius;\n }\n pathSegment(ctx, bounds, opts) {\n const {x, y, radius} = this;\n bounds = bounds || {start: 0, end: TAU};\n ctx.arc(x, y, radius, bounds.end, bounds.start, true);\n return !opts.bounds;\n }\n interpolate(point) {\n const {x, y, radius} = this;\n const angle = point.angle;\n return {\n x: x + Math.cos(angle) * radius,\n y: y + Math.sin(angle) * radius,\n angle\n };\n }\n}\n\nfunction _getTarget(source) {\n const {chart, fill, line} = source;\n if (isNumberFinite(fill)) {\n return getLineByIndex(chart, fill);\n }\n if (fill === 'stack') {\n return _buildStackLine(source);\n }\n if (fill === 'shape') {\n return true;\n }\n const boundary = computeBoundary(source);\n if (boundary instanceof simpleArc) {\n return boundary;\n }\n return _createBoundaryLine(boundary, line);\n}\nfunction getLineByIndex(chart, index) {\n const meta = chart.getDatasetMeta(index);\n const visible = meta && chart.isDatasetVisible(index);\n return visible ? meta.dataset : null;\n}\nfunction computeBoundary(source) {\n const scale = source.scale || {};\n if (scale.getPointPositionForValue) {\n return computeCircularBoundary(source);\n }\n return computeLinearBoundary(source);\n}\nfunction computeLinearBoundary(source) {\n const {scale = {}, fill} = source;\n const pixel = _getTargetPixel(fill, scale);\n if (isNumberFinite(pixel)) {\n const horizontal = scale.isHorizontal();\n return {\n x: horizontal ? pixel : null,\n y: horizontal ? null : pixel\n };\n }\n return null;\n}\nfunction computeCircularBoundary(source) {\n const {scale, fill} = source;\n const options = scale.options;\n const length = scale.getLabels().length;\n const start = options.reverse ? scale.max : scale.min;\n const value = _getTargetValue(fill, scale, start);\n const target = [];\n if (options.grid.circular) {\n const center = scale.getPointPositionForValue(0, start);\n return new simpleArc({\n x: center.x,\n y: center.y,\n radius: scale.getDistanceFromCenterForValue(value)\n });\n }\n for (let i = 0; i < length; ++i) {\n target.push(scale.getPointPositionForValue(i, value));\n }\n return target;\n}\n\nfunction _drawfill(ctx, source, area) {\n const target = _getTarget(source);\n const {line, scale, axis} = source;\n const lineOpts = line.options;\n const fillOption = lineOpts.fill;\n const color = lineOpts.backgroundColor;\n const {above = color, below = color} = fillOption || {};\n if (target && line.points.length) {\n clipArea(ctx, area);\n doFill(ctx, {line, target, above, below, area, scale, axis});\n unclipArea(ctx);\n }\n}\nfunction doFill(ctx, cfg) {\n const {line, target, above, below, area, scale} = cfg;\n const property = line._loop ? 'angle' : cfg.axis;\n ctx.save();\n if (property === 'x' && below !== above) {\n clipVertical(ctx, target, area.top);\n fill(ctx, {line, target, color: above, scale, property});\n ctx.restore();\n ctx.save();\n clipVertical(ctx, target, area.bottom);\n }\n fill(ctx, {line, target, color: below, scale, property});\n ctx.restore();\n}\nfunction clipVertical(ctx, target, clipY) {\n const {segments, points} = target;\n let first = true;\n let lineLoop = false;\n ctx.beginPath();\n for (const segment of segments) {\n const {start, end} = segment;\n const firstPoint = points[start];\n const lastPoint = points[_findSegmentEnd(start, end, points)];\n if (first) {\n ctx.moveTo(firstPoint.x, firstPoint.y);\n first = false;\n } else {\n ctx.lineTo(firstPoint.x, clipY);\n ctx.lineTo(firstPoint.x, firstPoint.y);\n }\n lineLoop = !!target.pathSegment(ctx, segment, {move: lineLoop});\n if (lineLoop) {\n ctx.closePath();\n } else {\n ctx.lineTo(lastPoint.x, clipY);\n }\n }\n ctx.lineTo(target.first().x, clipY);\n ctx.closePath();\n ctx.clip();\n}\nfunction fill(ctx, cfg) {\n const {line, target, property, color, scale} = cfg;\n const segments = _segments(line, target, property);\n for (const {source: src, target: tgt, start, end} of segments) {\n const {style: {backgroundColor = color} = {}} = src;\n const notShape = target !== true;\n ctx.save();\n ctx.fillStyle = backgroundColor;\n clipBounds(ctx, scale, notShape && _getBounds(property, start, end));\n ctx.beginPath();\n const lineLoop = !!line.pathSegment(ctx, src);\n let loop;\n if (notShape) {\n if (lineLoop) {\n ctx.closePath();\n } else {\n interpolatedLineTo(ctx, target, end, property);\n }\n const targetLoop = !!target.pathSegment(ctx, tgt, {move: lineLoop, reverse: true});\n loop = lineLoop && targetLoop;\n if (!loop) {\n interpolatedLineTo(ctx, target, start, property);\n }\n }\n ctx.closePath();\n ctx.fill(loop ? 'evenodd' : 'nonzero');\n ctx.restore();\n }\n}\nfunction clipBounds(ctx, scale, bounds) {\n const {top, bottom} = scale.chart.chartArea;\n const {property, start, end} = bounds || {};\n if (property === 'x') {\n ctx.beginPath();\n ctx.rect(start, top, end - start, bottom - top);\n ctx.clip();\n }\n}\nfunction interpolatedLineTo(ctx, target, point, property) {\n const interpolatedPoint = target.interpolate(point, property);\n if (interpolatedPoint) {\n ctx.lineTo(interpolatedPoint.x, interpolatedPoint.y);\n }\n}\n\nvar index = {\n id: 'filler',\n afterDatasetsUpdate(chart, _args, options) {\n const count = (chart.data.datasets || []).length;\n const sources = [];\n let meta, i, line, source;\n for (i = 0; i < count; ++i) {\n meta = chart.getDatasetMeta(i);\n line = meta.dataset;\n source = null;\n if (line && line.options && line instanceof LineElement) {\n source = {\n visible: chart.isDatasetVisible(i),\n index: i,\n fill: _decodeFill(line, i, count),\n chart,\n axis: meta.controller.options.indexAxis,\n scale: meta.vScale,\n line,\n };\n }\n meta.$filler = source;\n sources.push(source);\n }\n for (i = 0; i < count; ++i) {\n source = sources[i];\n if (!source || source.fill === false) {\n continue;\n }\n source.fill = _resolveTarget(sources, i, options.propagate);\n }\n },\n beforeDraw(chart, _args, options) {\n const draw = options.drawTime === 'beforeDraw';\n const metasets = chart.getSortedVisibleDatasetMetas();\n const area = chart.chartArea;\n for (let i = metasets.length - 1; i >= 0; --i) {\n const source = metasets[i].$filler;\n if (!source) {\n continue;\n }\n source.line.updateControlPoints(area, source.axis);\n if (draw) {\n _drawfill(chart.ctx, source, area);\n }\n }\n },\n beforeDatasetsDraw(chart, _args, options) {\n if (options.drawTime !== 'beforeDatasetsDraw') {\n return;\n }\n const metasets = chart.getSortedVisibleDatasetMetas();\n for (let i = metasets.length - 1; i >= 0; --i) {\n const source = metasets[i].$filler;\n if (source) {\n _drawfill(chart.ctx, source, chart.chartArea);\n }\n }\n },\n beforeDatasetDraw(chart, args, options) {\n const source = args.meta.$filler;\n if (!source || source.fill === false || options.drawTime !== 'beforeDatasetDraw') {\n return;\n }\n _drawfill(chart.ctx, source, chart.chartArea);\n },\n defaults: {\n propagate: true,\n drawTime: 'beforeDatasetDraw'\n }\n};\n\nconst getBoxSize = (labelOpts, fontSize) => {\n let {boxHeight = fontSize, boxWidth = fontSize} = labelOpts;\n if (labelOpts.usePointStyle) {\n boxHeight = Math.min(boxHeight, fontSize);\n boxWidth = Math.min(boxWidth, fontSize);\n }\n return {\n boxWidth,\n boxHeight,\n itemHeight: Math.max(fontSize, boxHeight)\n };\n};\nconst itemsEqual = (a, b) => a !== null && b !== null && a.datasetIndex === b.datasetIndex && a.index === b.index;\nclass Legend extends Element {\n constructor(config) {\n super();\n this._added = false;\n this.legendHitBoxes = [];\n this._hoveredItem = null;\n this.doughnutMode = false;\n this.chart = config.chart;\n this.options = config.options;\n this.ctx = config.ctx;\n this.legendItems = undefined;\n this.columnSizes = undefined;\n this.lineWidths = undefined;\n this.maxHeight = undefined;\n this.maxWidth = undefined;\n this.top = undefined;\n this.bottom = undefined;\n this.left = undefined;\n this.right = undefined;\n this.height = undefined;\n this.width = undefined;\n this._margins = undefined;\n this.position = undefined;\n this.weight = undefined;\n this.fullSize = undefined;\n }\n update(maxWidth, maxHeight, margins) {\n this.maxWidth = maxWidth;\n this.maxHeight = maxHeight;\n this._margins = margins;\n this.setDimensions();\n this.buildLabels();\n this.fit();\n }\n setDimensions() {\n if (this.isHorizontal()) {\n this.width = this.maxWidth;\n this.left = this._margins.left;\n this.right = this.width;\n } else {\n this.height = this.maxHeight;\n this.top = this._margins.top;\n this.bottom = this.height;\n }\n }\n buildLabels() {\n const labelOpts = this.options.labels || {};\n let legendItems = callback(labelOpts.generateLabels, [this.chart], this) || [];\n if (labelOpts.filter) {\n legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data));\n }\n if (labelOpts.sort) {\n legendItems = legendItems.sort((a, b) => labelOpts.sort(a, b, this.chart.data));\n }\n if (this.options.reverse) {\n legendItems.reverse();\n }\n this.legendItems = legendItems;\n }\n fit() {\n const {options, ctx} = this;\n if (!options.display) {\n this.width = this.height = 0;\n return;\n }\n const labelOpts = options.labels;\n const labelFont = toFont(labelOpts.font);\n const fontSize = labelFont.size;\n const titleHeight = this._computeTitleHeight();\n const {boxWidth, itemHeight} = getBoxSize(labelOpts, fontSize);\n let width, height;\n ctx.font = labelFont.string;\n if (this.isHorizontal()) {\n width = this.maxWidth;\n height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10;\n } else {\n height = this.maxHeight;\n width = this._fitCols(titleHeight, fontSize, boxWidth, itemHeight) + 10;\n }\n this.width = Math.min(width, options.maxWidth || this.maxWidth);\n this.height = Math.min(height, options.maxHeight || this.maxHeight);\n }\n _fitRows(titleHeight, fontSize, boxWidth, itemHeight) {\n const {ctx, maxWidth, options: {labels: {padding}}} = this;\n const hitboxes = this.legendHitBoxes = [];\n const lineWidths = this.lineWidths = [0];\n const lineHeight = itemHeight + padding;\n let totalHeight = titleHeight;\n ctx.textAlign = 'left';\n ctx.textBaseline = 'middle';\n let row = -1;\n let top = -lineHeight;\n this.legendItems.forEach((legendItem, i) => {\n const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;\n if (i === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) {\n totalHeight += lineHeight;\n lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0;\n top += lineHeight;\n row++;\n }\n hitboxes[i] = {left: 0, top, row, width: itemWidth, height: itemHeight};\n lineWidths[lineWidths.length - 1] += itemWidth + padding;\n });\n return totalHeight;\n }\n _fitCols(titleHeight, fontSize, boxWidth, itemHeight) {\n const {ctx, maxHeight, options: {labels: {padding}}} = this;\n const hitboxes = this.legendHitBoxes = [];\n const columnSizes = this.columnSizes = [];\n const heightLimit = maxHeight - titleHeight;\n let totalWidth = padding;\n let currentColWidth = 0;\n let currentColHeight = 0;\n let left = 0;\n let col = 0;\n this.legendItems.forEach((legendItem, i) => {\n const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width;\n if (i > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) {\n totalWidth += currentColWidth + padding;\n columnSizes.push({width: currentColWidth, height: currentColHeight});\n left += currentColWidth + padding;\n col++;\n currentColWidth = currentColHeight = 0;\n }\n hitboxes[i] = {left, top: currentColHeight, col, width: itemWidth, height: itemHeight};\n currentColWidth = Math.max(currentColWidth, itemWidth);\n currentColHeight += itemHeight + padding;\n });\n totalWidth += currentColWidth;\n columnSizes.push({width: currentColWidth, height: currentColHeight});\n return totalWidth;\n }\n adjustHitBoxes() {\n if (!this.options.display) {\n return;\n }\n const titleHeight = this._computeTitleHeight();\n const {legendHitBoxes: hitboxes, options: {align, labels: {padding}, rtl}} = this;\n const rtlHelper = getRtlAdapter(rtl, this.left, this.width);\n if (this.isHorizontal()) {\n let row = 0;\n let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);\n for (const hitbox of hitboxes) {\n if (row !== hitbox.row) {\n row = hitbox.row;\n left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]);\n }\n hitbox.top += this.top + titleHeight + padding;\n hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width);\n left += hitbox.width + padding;\n }\n } else {\n let col = 0;\n let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);\n for (const hitbox of hitboxes) {\n if (hitbox.col !== col) {\n col = hitbox.col;\n top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height);\n }\n hitbox.top = top;\n hitbox.left += this.left + padding;\n hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width);\n top += hitbox.height + padding;\n }\n }\n }\n isHorizontal() {\n return this.options.position === 'top' || this.options.position === 'bottom';\n }\n draw() {\n if (this.options.display) {\n const ctx = this.ctx;\n clipArea(ctx, this);\n this._draw();\n unclipArea(ctx);\n }\n }\n _draw() {\n const {options: opts, columnSizes, lineWidths, ctx} = this;\n const {align, labels: labelOpts} = opts;\n const defaultColor = defaults.color;\n const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);\n const labelFont = toFont(labelOpts.font);\n const {color: fontColor, padding} = labelOpts;\n const fontSize = labelFont.size;\n const halfFontSize = fontSize / 2;\n let cursor;\n this.drawTitle();\n ctx.textAlign = rtlHelper.textAlign('left');\n ctx.textBaseline = 'middle';\n ctx.lineWidth = 0.5;\n ctx.font = labelFont.string;\n const {boxWidth, boxHeight, itemHeight} = getBoxSize(labelOpts, fontSize);\n const drawLegendBox = function(x, y, legendItem) {\n if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) {\n return;\n }\n ctx.save();\n const lineWidth = valueOrDefault(legendItem.lineWidth, 1);\n ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor);\n ctx.lineCap = valueOrDefault(legendItem.lineCap, 'butt');\n ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0);\n ctx.lineJoin = valueOrDefault(legendItem.lineJoin, 'miter');\n ctx.lineWidth = lineWidth;\n ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor);\n ctx.setLineDash(valueOrDefault(legendItem.lineDash, []));\n if (labelOpts.usePointStyle) {\n const drawOptions = {\n radius: boxWidth * Math.SQRT2 / 2,\n pointStyle: legendItem.pointStyle,\n rotation: legendItem.rotation,\n borderWidth: lineWidth\n };\n const centerX = rtlHelper.xPlus(x, boxWidth / 2);\n const centerY = y + halfFontSize;\n drawPoint(ctx, drawOptions, centerX, centerY);\n } else {\n const yBoxTop = y + Math.max((fontSize - boxHeight) / 2, 0);\n const xBoxLeft = rtlHelper.leftForLtr(x, boxWidth);\n const borderRadius = toTRBLCorners(legendItem.borderRadius);\n ctx.beginPath();\n if (Object.values(borderRadius).some(v => v !== 0)) {\n addRoundedRectPath(ctx, {\n x: xBoxLeft,\n y: yBoxTop,\n w: boxWidth,\n h: boxHeight,\n radius: borderRadius,\n });\n } else {\n ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight);\n }\n ctx.fill();\n if (lineWidth !== 0) {\n ctx.stroke();\n }\n }\n ctx.restore();\n };\n const fillText = function(x, y, legendItem) {\n renderText(ctx, legendItem.text, x, y + (itemHeight / 2), labelFont, {\n strikethrough: legendItem.hidden,\n textAlign: rtlHelper.textAlign(legendItem.textAlign)\n });\n };\n const isHorizontal = this.isHorizontal();\n const titleHeight = this._computeTitleHeight();\n if (isHorizontal) {\n cursor = {\n x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]),\n y: this.top + padding + titleHeight,\n line: 0\n };\n } else {\n cursor = {\n x: this.left + padding,\n y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height),\n line: 0\n };\n }\n overrideTextDirection(this.ctx, opts.textDirection);\n const lineHeight = itemHeight + padding;\n this.legendItems.forEach((legendItem, i) => {\n ctx.strokeStyle = legendItem.fontColor || fontColor;\n ctx.fillStyle = legendItem.fontColor || fontColor;\n const textWidth = ctx.measureText(legendItem.text).width;\n const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign));\n const width = boxWidth + halfFontSize + textWidth;\n let x = cursor.x;\n let y = cursor.y;\n rtlHelper.setWidth(this.width);\n if (isHorizontal) {\n if (i > 0 && x + width + padding > this.right) {\n y = cursor.y += lineHeight;\n cursor.line++;\n x = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]);\n }\n } else if (i > 0 && y + lineHeight > this.bottom) {\n x = cursor.x = x + columnSizes[cursor.line].width + padding;\n cursor.line++;\n y = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height);\n }\n const realX = rtlHelper.x(x);\n drawLegendBox(realX, y, legendItem);\n x = _textX(textAlign, x + boxWidth + halfFontSize, isHorizontal ? x + width : this.right, opts.rtl);\n fillText(rtlHelper.x(x), y, legendItem);\n if (isHorizontal) {\n cursor.x += width + padding;\n } else {\n cursor.y += lineHeight;\n }\n });\n restoreTextDirection(this.ctx, opts.textDirection);\n }\n drawTitle() {\n const opts = this.options;\n const titleOpts = opts.title;\n const titleFont = toFont(titleOpts.font);\n const titlePadding = toPadding(titleOpts.padding);\n if (!titleOpts.display) {\n return;\n }\n const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width);\n const ctx = this.ctx;\n const position = titleOpts.position;\n const halfFontSize = titleFont.size / 2;\n const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize;\n let y;\n let left = this.left;\n let maxWidth = this.width;\n if (this.isHorizontal()) {\n maxWidth = Math.max(...this.lineWidths);\n y = this.top + topPaddingPlusHalfFontSize;\n left = _alignStartEnd(opts.align, left, this.right - maxWidth);\n } else {\n const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0);\n y = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight());\n }\n const x = _alignStartEnd(position, left, left + maxWidth);\n ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position));\n ctx.textBaseline = 'middle';\n ctx.strokeStyle = titleOpts.color;\n ctx.fillStyle = titleOpts.color;\n ctx.font = titleFont.string;\n renderText(ctx, titleOpts.text, x, y, titleFont);\n }\n _computeTitleHeight() {\n const titleOpts = this.options.title;\n const titleFont = toFont(titleOpts.font);\n const titlePadding = toPadding(titleOpts.padding);\n return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0;\n }\n _getLegendItemAt(x, y) {\n let i, hitBox, lh;\n if (_isBetween(x, this.left, this.right)\n && _isBetween(y, this.top, this.bottom)) {\n lh = this.legendHitBoxes;\n for (i = 0; i < lh.length; ++i) {\n hitBox = lh[i];\n if (_isBetween(x, hitBox.left, hitBox.left + hitBox.width)\n && _isBetween(y, hitBox.top, hitBox.top + hitBox.height)) {\n return this.legendItems[i];\n }\n }\n }\n return null;\n }\n handleEvent(e) {\n const opts = this.options;\n if (!isListened(e.type, opts)) {\n return;\n }\n const hoveredItem = this._getLegendItemAt(e.x, e.y);\n if (e.type === 'mousemove' || e.type === 'mouseout') {\n const previous = this._hoveredItem;\n const sameItem = itemsEqual(previous, hoveredItem);\n if (previous && !sameItem) {\n callback(opts.onLeave, [e, previous, this], this);\n }\n this._hoveredItem = hoveredItem;\n if (hoveredItem && !sameItem) {\n callback(opts.onHover, [e, hoveredItem, this], this);\n }\n } else if (hoveredItem) {\n callback(opts.onClick, [e, hoveredItem, this], this);\n }\n }\n}\nfunction isListened(type, opts) {\n if ((type === 'mousemove' || type === 'mouseout') && (opts.onHover || opts.onLeave)) {\n return true;\n }\n if (opts.onClick && (type === 'click' || type === 'mouseup')) {\n return true;\n }\n return false;\n}\nvar plugin_legend = {\n id: 'legend',\n _element: Legend,\n start(chart, _args, options) {\n const legend = chart.legend = new Legend({ctx: chart.ctx, options, chart});\n layouts.configure(chart, legend, options);\n layouts.addBox(chart, legend);\n },\n stop(chart) {\n layouts.removeBox(chart, chart.legend);\n delete chart.legend;\n },\n beforeUpdate(chart, _args, options) {\n const legend = chart.legend;\n layouts.configure(chart, legend, options);\n legend.options = options;\n },\n afterUpdate(chart) {\n const legend = chart.legend;\n legend.buildLabels();\n legend.adjustHitBoxes();\n },\n afterEvent(chart, args) {\n if (!args.replay) {\n chart.legend.handleEvent(args.event);\n }\n },\n defaults: {\n display: true,\n position: 'top',\n align: 'center',\n fullSize: true,\n reverse: false,\n weight: 1000,\n onClick(e, legendItem, legend) {\n const index = legendItem.datasetIndex;\n const ci = legend.chart;\n if (ci.isDatasetVisible(index)) {\n ci.hide(index);\n legendItem.hidden = true;\n } else {\n ci.show(index);\n legendItem.hidden = false;\n }\n },\n onHover: null,\n onLeave: null,\n labels: {\n color: (ctx) => ctx.chart.options.color,\n boxWidth: 40,\n padding: 10,\n generateLabels(chart) {\n const datasets = chart.data.datasets;\n const {labels: {usePointStyle, pointStyle, textAlign, color}} = chart.legend.options;\n return chart._getSortedDatasetMetas().map((meta) => {\n const style = meta.controller.getStyle(usePointStyle ? 0 : undefined);\n const borderWidth = toPadding(style.borderWidth);\n return {\n text: datasets[meta.index].label,\n fillStyle: style.backgroundColor,\n fontColor: color,\n hidden: !meta.visible,\n lineCap: style.borderCapStyle,\n lineDash: style.borderDash,\n lineDashOffset: style.borderDashOffset,\n lineJoin: style.borderJoinStyle,\n lineWidth: (borderWidth.width + borderWidth.height) / 4,\n strokeStyle: style.borderColor,\n pointStyle: pointStyle || style.pointStyle,\n rotation: style.rotation,\n textAlign: textAlign || style.textAlign,\n borderRadius: 0,\n datasetIndex: meta.index\n };\n }, this);\n }\n },\n title: {\n color: (ctx) => ctx.chart.options.color,\n display: false,\n position: 'center',\n text: '',\n }\n },\n descriptors: {\n _scriptable: (name) => !name.startsWith('on'),\n labels: {\n _scriptable: (name) => !['generateLabels', 'filter', 'sort'].includes(name),\n }\n },\n};\n\nclass Title extends Element {\n constructor(config) {\n super();\n this.chart = config.chart;\n this.options = config.options;\n this.ctx = config.ctx;\n this._padding = undefined;\n this.top = undefined;\n this.bottom = undefined;\n this.left = undefined;\n this.right = undefined;\n this.width = undefined;\n this.height = undefined;\n this.position = undefined;\n this.weight = undefined;\n this.fullSize = undefined;\n }\n update(maxWidth, maxHeight) {\n const opts = this.options;\n this.left = 0;\n this.top = 0;\n if (!opts.display) {\n this.width = this.height = this.right = this.bottom = 0;\n return;\n }\n this.width = this.right = maxWidth;\n this.height = this.bottom = maxHeight;\n const lineCount = isArray(opts.text) ? opts.text.length : 1;\n this._padding = toPadding(opts.padding);\n const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height;\n if (this.isHorizontal()) {\n this.height = textSize;\n } else {\n this.width = textSize;\n }\n }\n isHorizontal() {\n const pos = this.options.position;\n return pos === 'top' || pos === 'bottom';\n }\n _drawArgs(offset) {\n const {top, left, bottom, right, options} = this;\n const align = options.align;\n let rotation = 0;\n let maxWidth, titleX, titleY;\n if (this.isHorizontal()) {\n titleX = _alignStartEnd(align, left, right);\n titleY = top + offset;\n maxWidth = right - left;\n } else {\n if (options.position === 'left') {\n titleX = left + offset;\n titleY = _alignStartEnd(align, bottom, top);\n rotation = PI * -0.5;\n } else {\n titleX = right - offset;\n titleY = _alignStartEnd(align, top, bottom);\n rotation = PI * 0.5;\n }\n maxWidth = bottom - top;\n }\n return {titleX, titleY, maxWidth, rotation};\n }\n draw() {\n const ctx = this.ctx;\n const opts = this.options;\n if (!opts.display) {\n return;\n }\n const fontOpts = toFont(opts.font);\n const lineHeight = fontOpts.lineHeight;\n const offset = lineHeight / 2 + this._padding.top;\n const {titleX, titleY, maxWidth, rotation} = this._drawArgs(offset);\n renderText(ctx, opts.text, 0, 0, fontOpts, {\n color: opts.color,\n maxWidth,\n rotation,\n textAlign: _toLeftRightCenter(opts.align),\n textBaseline: 'middle',\n translation: [titleX, titleY],\n });\n }\n}\nfunction createTitle(chart, titleOpts) {\n const title = new Title({\n ctx: chart.ctx,\n options: titleOpts,\n chart\n });\n layouts.configure(chart, title, titleOpts);\n layouts.addBox(chart, title);\n chart.titleBlock = title;\n}\nvar plugin_title = {\n id: 'title',\n _element: Title,\n start(chart, _args, options) {\n createTitle(chart, options);\n },\n stop(chart) {\n const titleBlock = chart.titleBlock;\n layouts.removeBox(chart, titleBlock);\n delete chart.titleBlock;\n },\n beforeUpdate(chart, _args, options) {\n const title = chart.titleBlock;\n layouts.configure(chart, title, options);\n title.options = options;\n },\n defaults: {\n align: 'center',\n display: false,\n font: {\n weight: 'bold',\n },\n fullSize: true,\n padding: 10,\n position: 'top',\n text: '',\n weight: 2000\n },\n defaultRoutes: {\n color: 'color'\n },\n descriptors: {\n _scriptable: true,\n _indexable: false,\n },\n};\n\nconst map = new WeakMap();\nvar plugin_subtitle = {\n id: 'subtitle',\n start(chart, _args, options) {\n const title = new Title({\n ctx: chart.ctx,\n options,\n chart\n });\n layouts.configure(chart, title, options);\n layouts.addBox(chart, title);\n map.set(chart, title);\n },\n stop(chart) {\n layouts.removeBox(chart, map.get(chart));\n map.delete(chart);\n },\n beforeUpdate(chart, _args, options) {\n const title = map.get(chart);\n layouts.configure(chart, title, options);\n title.options = options;\n },\n defaults: {\n align: 'center',\n display: false,\n font: {\n weight: 'normal',\n },\n fullSize: true,\n padding: 0,\n position: 'top',\n text: '',\n weight: 1500\n },\n defaultRoutes: {\n color: 'color'\n },\n descriptors: {\n _scriptable: true,\n _indexable: false,\n },\n};\n\nconst positioners = {\n average(items) {\n if (!items.length) {\n return false;\n }\n let i, len;\n let x = 0;\n let y = 0;\n let count = 0;\n for (i = 0, len = items.length; i < len; ++i) {\n const el = items[i].element;\n if (el && el.hasValue()) {\n const pos = el.tooltipPosition();\n x += pos.x;\n y += pos.y;\n ++count;\n }\n }\n return {\n x: x / count,\n y: y / count\n };\n },\n nearest(items, eventPosition) {\n if (!items.length) {\n return false;\n }\n let x = eventPosition.x;\n let y = eventPosition.y;\n let minDistance = Number.POSITIVE_INFINITY;\n let i, len, nearestElement;\n for (i = 0, len = items.length; i < len; ++i) {\n const el = items[i].element;\n if (el && el.hasValue()) {\n const center = el.getCenterPoint();\n const d = distanceBetweenPoints(eventPosition, center);\n if (d < minDistance) {\n minDistance = d;\n nearestElement = el;\n }\n }\n }\n if (nearestElement) {\n const tp = nearestElement.tooltipPosition();\n x = tp.x;\n y = tp.y;\n }\n return {\n x,\n y\n };\n }\n};\nfunction pushOrConcat(base, toPush) {\n if (toPush) {\n if (isArray(toPush)) {\n Array.prototype.push.apply(base, toPush);\n } else {\n base.push(toPush);\n }\n }\n return base;\n}\nfunction splitNewlines(str) {\n if ((typeof str === 'string' || str instanceof String) && str.indexOf('\\n') > -1) {\n return str.split('\\n');\n }\n return str;\n}\nfunction createTooltipItem(chart, item) {\n const {element, datasetIndex, index} = item;\n const controller = chart.getDatasetMeta(datasetIndex).controller;\n const {label, value} = controller.getLabelAndValue(index);\n return {\n chart,\n label,\n parsed: controller.getParsed(index),\n raw: chart.data.datasets[datasetIndex].data[index],\n formattedValue: value,\n dataset: controller.getDataset(),\n dataIndex: index,\n datasetIndex,\n element\n };\n}\nfunction getTooltipSize(tooltip, options) {\n const ctx = tooltip.chart.ctx;\n const {body, footer, title} = tooltip;\n const {boxWidth, boxHeight} = options;\n const bodyFont = toFont(options.bodyFont);\n const titleFont = toFont(options.titleFont);\n const footerFont = toFont(options.footerFont);\n const titleLineCount = title.length;\n const footerLineCount = footer.length;\n const bodyLineItemCount = body.length;\n const padding = toPadding(options.padding);\n let height = padding.height;\n let width = 0;\n let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0);\n combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length;\n if (titleLineCount) {\n height += titleLineCount * titleFont.lineHeight\n\t\t\t+ (titleLineCount - 1) * options.titleSpacing\n\t\t\t+ options.titleMarginBottom;\n }\n if (combinedBodyLength) {\n const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight;\n height += bodyLineItemCount * bodyLineHeight\n\t\t\t+ (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight\n\t\t\t+ (combinedBodyLength - 1) * options.bodySpacing;\n }\n if (footerLineCount) {\n height += options.footerMarginTop\n\t\t\t+ footerLineCount * footerFont.lineHeight\n\t\t\t+ (footerLineCount - 1) * options.footerSpacing;\n }\n let widthPadding = 0;\n const maxLineWidth = function(line) {\n width = Math.max(width, ctx.measureText(line).width + widthPadding);\n };\n ctx.save();\n ctx.font = titleFont.string;\n each(tooltip.title, maxLineWidth);\n ctx.font = bodyFont.string;\n each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth);\n widthPadding = options.displayColors ? (boxWidth + 2 + options.boxPadding) : 0;\n each(body, (bodyItem) => {\n each(bodyItem.before, maxLineWidth);\n each(bodyItem.lines, maxLineWidth);\n each(bodyItem.after, maxLineWidth);\n });\n widthPadding = 0;\n ctx.font = footerFont.string;\n each(tooltip.footer, maxLineWidth);\n ctx.restore();\n width += padding.width;\n return {width, height};\n}\nfunction determineYAlign(chart, size) {\n const {y, height} = size;\n if (y < height / 2) {\n return 'top';\n } else if (y > (chart.height - height / 2)) {\n return 'bottom';\n }\n return 'center';\n}\nfunction doesNotFitWithAlign(xAlign, chart, options, size) {\n const {x, width} = size;\n const caret = options.caretSize + options.caretPadding;\n if (xAlign === 'left' && x + width + caret > chart.width) {\n return true;\n }\n if (xAlign === 'right' && x - width - caret < 0) {\n return true;\n }\n}\nfunction determineXAlign(chart, options, size, yAlign) {\n const {x, width} = size;\n const {width: chartWidth, chartArea: {left, right}} = chart;\n let xAlign = 'center';\n if (yAlign === 'center') {\n xAlign = x <= (left + right) / 2 ? 'left' : 'right';\n } else if (x <= width / 2) {\n xAlign = 'left';\n } else if (x >= chartWidth - width / 2) {\n xAlign = 'right';\n }\n if (doesNotFitWithAlign(xAlign, chart, options, size)) {\n xAlign = 'center';\n }\n return xAlign;\n}\nfunction determineAlignment(chart, options, size) {\n const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);\n return {\n xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),\n yAlign\n };\n}\nfunction alignX(size, xAlign) {\n let {x, width} = size;\n if (xAlign === 'right') {\n x -= width;\n } else if (xAlign === 'center') {\n x -= (width / 2);\n }\n return x;\n}\nfunction alignY(size, yAlign, paddingAndSize) {\n let {y, height} = size;\n if (yAlign === 'top') {\n y += paddingAndSize;\n } else if (yAlign === 'bottom') {\n y -= height + paddingAndSize;\n } else {\n y -= (height / 2);\n }\n return y;\n}\nfunction getBackgroundPoint(options, size, alignment, chart) {\n const {caretSize, caretPadding, cornerRadius} = options;\n const {xAlign, yAlign} = alignment;\n const paddingAndSize = caretSize + caretPadding;\n const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);\n let x = alignX(size, xAlign);\n const y = alignY(size, yAlign, paddingAndSize);\n if (yAlign === 'center') {\n if (xAlign === 'left') {\n x += paddingAndSize;\n } else if (xAlign === 'right') {\n x -= paddingAndSize;\n }\n } else if (xAlign === 'left') {\n x -= Math.max(topLeft, bottomLeft) + caretSize;\n } else if (xAlign === 'right') {\n x += Math.max(topRight, bottomRight) + caretSize;\n }\n return {\n x: _limitValue(x, 0, chart.width - size.width),\n y: _limitValue(y, 0, chart.height - size.height)\n };\n}\nfunction getAlignedX(tooltip, align, options) {\n const padding = toPadding(options.padding);\n return align === 'center'\n ? tooltip.x + tooltip.width / 2\n : align === 'right'\n ? tooltip.x + tooltip.width - padding.right\n : tooltip.x + padding.left;\n}\nfunction getBeforeAfterBodyLines(callback) {\n return pushOrConcat([], splitNewlines(callback));\n}\nfunction createTooltipContext(parent, tooltip, tooltipItems) {\n return createContext(parent, {\n tooltip,\n tooltipItems,\n type: 'tooltip'\n });\n}\nfunction overrideCallbacks(callbacks, context) {\n const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks;\n return override ? callbacks.override(override) : callbacks;\n}\nclass Tooltip extends Element {\n constructor(config) {\n super();\n this.opacity = 0;\n this._active = [];\n this._eventPosition = undefined;\n this._size = undefined;\n this._cachedAnimations = undefined;\n this._tooltipItems = [];\n this.$animations = undefined;\n this.$context = undefined;\n this.chart = config.chart || config._chart;\n this._chart = this.chart;\n this.options = config.options;\n this.dataPoints = undefined;\n this.title = undefined;\n this.beforeBody = undefined;\n this.body = undefined;\n this.afterBody = undefined;\n this.footer = undefined;\n this.xAlign = undefined;\n this.yAlign = undefined;\n this.x = undefined;\n this.y = undefined;\n this.height = undefined;\n this.width = undefined;\n this.caretX = undefined;\n this.caretY = undefined;\n this.labelColors = undefined;\n this.labelPointStyles = undefined;\n this.labelTextColors = undefined;\n }\n initialize(options) {\n this.options = options;\n this._cachedAnimations = undefined;\n this.$context = undefined;\n }\n _resolveAnimations() {\n const cached = this._cachedAnimations;\n if (cached) {\n return cached;\n }\n const chart = this.chart;\n const options = this.options.setContext(this.getContext());\n const opts = options.enabled && chart.options.animation && options.animations;\n const animations = new Animations(this.chart, opts);\n if (opts._cacheable) {\n this._cachedAnimations = Object.freeze(animations);\n }\n return animations;\n }\n getContext() {\n return this.$context ||\n\t\t\t(this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));\n }\n getTitle(context, options) {\n const {callbacks} = options;\n const beforeTitle = callbacks.beforeTitle.apply(this, [context]);\n const title = callbacks.title.apply(this, [context]);\n const afterTitle = callbacks.afterTitle.apply(this, [context]);\n let lines = [];\n lines = pushOrConcat(lines, splitNewlines(beforeTitle));\n lines = pushOrConcat(lines, splitNewlines(title));\n lines = pushOrConcat(lines, splitNewlines(afterTitle));\n return lines;\n }\n getBeforeBody(tooltipItems, options) {\n return getBeforeAfterBodyLines(options.callbacks.beforeBody.apply(this, [tooltipItems]));\n }\n getBody(tooltipItems, options) {\n const {callbacks} = options;\n const bodyItems = [];\n each(tooltipItems, (context) => {\n const bodyItem = {\n before: [],\n lines: [],\n after: []\n };\n const scoped = overrideCallbacks(callbacks, context);\n pushOrConcat(bodyItem.before, splitNewlines(scoped.beforeLabel.call(this, context)));\n pushOrConcat(bodyItem.lines, scoped.label.call(this, context));\n pushOrConcat(bodyItem.after, splitNewlines(scoped.afterLabel.call(this, context)));\n bodyItems.push(bodyItem);\n });\n return bodyItems;\n }\n getAfterBody(tooltipItems, options) {\n return getBeforeAfterBodyLines(options.callbacks.afterBody.apply(this, [tooltipItems]));\n }\n getFooter(tooltipItems, options) {\n const {callbacks} = options;\n const beforeFooter = callbacks.beforeFooter.apply(this, [tooltipItems]);\n const footer = callbacks.footer.apply(this, [tooltipItems]);\n const afterFooter = callbacks.afterFooter.apply(this, [tooltipItems]);\n let lines = [];\n lines = pushOrConcat(lines, splitNewlines(beforeFooter));\n lines = pushOrConcat(lines, splitNewlines(footer));\n lines = pushOrConcat(lines, splitNewlines(afterFooter));\n return lines;\n }\n _createItems(options) {\n const active = this._active;\n const data = this.chart.data;\n const labelColors = [];\n const labelPointStyles = [];\n const labelTextColors = [];\n let tooltipItems = [];\n let i, len;\n for (i = 0, len = active.length; i < len; ++i) {\n tooltipItems.push(createTooltipItem(this.chart, active[i]));\n }\n if (options.filter) {\n tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));\n }\n if (options.itemSort) {\n tooltipItems = tooltipItems.sort((a, b) => options.itemSort(a, b, data));\n }\n each(tooltipItems, (context) => {\n const scoped = overrideCallbacks(options.callbacks, context);\n labelColors.push(scoped.labelColor.call(this, context));\n labelPointStyles.push(scoped.labelPointStyle.call(this, context));\n labelTextColors.push(scoped.labelTextColor.call(this, context));\n });\n this.labelColors = labelColors;\n this.labelPointStyles = labelPointStyles;\n this.labelTextColors = labelTextColors;\n this.dataPoints = tooltipItems;\n return tooltipItems;\n }\n update(changed, replay) {\n const options = this.options.setContext(this.getContext());\n const active = this._active;\n let properties;\n let tooltipItems = [];\n if (!active.length) {\n if (this.opacity !== 0) {\n properties = {\n opacity: 0\n };\n }\n } else {\n const position = positioners[options.position].call(this, active, this._eventPosition);\n tooltipItems = this._createItems(options);\n this.title = this.getTitle(tooltipItems, options);\n this.beforeBody = this.getBeforeBody(tooltipItems, options);\n this.body = this.getBody(tooltipItems, options);\n this.afterBody = this.getAfterBody(tooltipItems, options);\n this.footer = this.getFooter(tooltipItems, options);\n const size = this._size = getTooltipSize(this, options);\n const positionAndSize = Object.assign({}, position, size);\n const alignment = determineAlignment(this.chart, options, positionAndSize);\n const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);\n this.xAlign = alignment.xAlign;\n this.yAlign = alignment.yAlign;\n properties = {\n opacity: 1,\n x: backgroundPoint.x,\n y: backgroundPoint.y,\n width: size.width,\n height: size.height,\n caretX: position.x,\n caretY: position.y\n };\n }\n this._tooltipItems = tooltipItems;\n this.$context = undefined;\n if (properties) {\n this._resolveAnimations().update(this, properties);\n }\n if (changed && options.external) {\n options.external.call(this, {chart: this.chart, tooltip: this, replay});\n }\n }\n drawCaret(tooltipPoint, ctx, size, options) {\n const caretPosition = this.getCaretPosition(tooltipPoint, size, options);\n ctx.lineTo(caretPosition.x1, caretPosition.y1);\n ctx.lineTo(caretPosition.x2, caretPosition.y2);\n ctx.lineTo(caretPosition.x3, caretPosition.y3);\n }\n getCaretPosition(tooltipPoint, size, options) {\n const {xAlign, yAlign} = this;\n const {caretSize, cornerRadius} = options;\n const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius);\n const {x: ptX, y: ptY} = tooltipPoint;\n const {width, height} = size;\n let x1, x2, x3, y1, y2, y3;\n if (yAlign === 'center') {\n y2 = ptY + (height / 2);\n if (xAlign === 'left') {\n x1 = ptX;\n x2 = x1 - caretSize;\n y1 = y2 + caretSize;\n y3 = y2 - caretSize;\n } else {\n x1 = ptX + width;\n x2 = x1 + caretSize;\n y1 = y2 - caretSize;\n y3 = y2 + caretSize;\n }\n x3 = x1;\n } else {\n if (xAlign === 'left') {\n x2 = ptX + Math.max(topLeft, bottomLeft) + (caretSize);\n } else if (xAlign === 'right') {\n x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize;\n } else {\n x2 = this.caretX;\n }\n if (yAlign === 'top') {\n y1 = ptY;\n y2 = y1 - caretSize;\n x1 = x2 - caretSize;\n x3 = x2 + caretSize;\n } else {\n y1 = ptY + height;\n y2 = y1 + caretSize;\n x1 = x2 + caretSize;\n x3 = x2 - caretSize;\n }\n y3 = y1;\n }\n return {x1, x2, x3, y1, y2, y3};\n }\n drawTitle(pt, ctx, options) {\n const title = this.title;\n const length = title.length;\n let titleFont, titleSpacing, i;\n if (length) {\n const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n pt.x = getAlignedX(this, options.titleAlign, options);\n ctx.textAlign = rtlHelper.textAlign(options.titleAlign);\n ctx.textBaseline = 'middle';\n titleFont = toFont(options.titleFont);\n titleSpacing = options.titleSpacing;\n ctx.fillStyle = options.titleColor;\n ctx.font = titleFont.string;\n for (i = 0; i < length; ++i) {\n ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2);\n pt.y += titleFont.lineHeight + titleSpacing;\n if (i + 1 === length) {\n pt.y += options.titleMarginBottom - titleSpacing;\n }\n }\n }\n }\n _drawColorBox(ctx, pt, i, rtlHelper, options) {\n const labelColors = this.labelColors[i];\n const labelPointStyle = this.labelPointStyles[i];\n const {boxHeight, boxWidth, boxPadding} = options;\n const bodyFont = toFont(options.bodyFont);\n const colorX = getAlignedX(this, 'left', options);\n const rtlColorX = rtlHelper.x(colorX);\n const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0;\n const colorY = pt.y + yOffSet;\n if (options.usePointStyle) {\n const drawOptions = {\n radius: Math.min(boxWidth, boxHeight) / 2,\n pointStyle: labelPointStyle.pointStyle,\n rotation: labelPointStyle.rotation,\n borderWidth: 1\n };\n const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2;\n const centerY = colorY + boxHeight / 2;\n ctx.strokeStyle = options.multiKeyBackground;\n ctx.fillStyle = options.multiKeyBackground;\n drawPoint(ctx, drawOptions, centerX, centerY);\n ctx.strokeStyle = labelColors.borderColor;\n ctx.fillStyle = labelColors.backgroundColor;\n drawPoint(ctx, drawOptions, centerX, centerY);\n } else {\n ctx.lineWidth = labelColors.borderWidth || 1;\n ctx.strokeStyle = labelColors.borderColor;\n ctx.setLineDash(labelColors.borderDash || []);\n ctx.lineDashOffset = labelColors.borderDashOffset || 0;\n const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth - boxPadding);\n const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - boxPadding - 2);\n const borderRadius = toTRBLCorners(labelColors.borderRadius);\n if (Object.values(borderRadius).some(v => v !== 0)) {\n ctx.beginPath();\n ctx.fillStyle = options.multiKeyBackground;\n addRoundedRectPath(ctx, {\n x: outerX,\n y: colorY,\n w: boxWidth,\n h: boxHeight,\n radius: borderRadius,\n });\n ctx.fill();\n ctx.stroke();\n ctx.fillStyle = labelColors.backgroundColor;\n ctx.beginPath();\n addRoundedRectPath(ctx, {\n x: innerX,\n y: colorY + 1,\n w: boxWidth - 2,\n h: boxHeight - 2,\n radius: borderRadius,\n });\n ctx.fill();\n } else {\n ctx.fillStyle = options.multiKeyBackground;\n ctx.fillRect(outerX, colorY, boxWidth, boxHeight);\n ctx.strokeRect(outerX, colorY, boxWidth, boxHeight);\n ctx.fillStyle = labelColors.backgroundColor;\n ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2);\n }\n }\n ctx.fillStyle = this.labelTextColors[i];\n }\n drawBody(pt, ctx, options) {\n const {body} = this;\n const {bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding} = options;\n const bodyFont = toFont(options.bodyFont);\n let bodyLineHeight = bodyFont.lineHeight;\n let xLinePadding = 0;\n const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n const fillLineOfText = function(line) {\n ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2);\n pt.y += bodyLineHeight + bodySpacing;\n };\n const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign);\n let bodyItem, textColor, lines, i, j, ilen, jlen;\n ctx.textAlign = bodyAlign;\n ctx.textBaseline = 'middle';\n ctx.font = bodyFont.string;\n pt.x = getAlignedX(this, bodyAlignForCalculation, options);\n ctx.fillStyle = options.bodyColor;\n each(this.beforeBody, fillLineOfText);\n xLinePadding = displayColors && bodyAlignForCalculation !== 'right'\n ? bodyAlign === 'center' ? (boxWidth / 2 + boxPadding) : (boxWidth + 2 + boxPadding)\n : 0;\n for (i = 0, ilen = body.length; i < ilen; ++i) {\n bodyItem = body[i];\n textColor = this.labelTextColors[i];\n ctx.fillStyle = textColor;\n each(bodyItem.before, fillLineOfText);\n lines = bodyItem.lines;\n if (displayColors && lines.length) {\n this._drawColorBox(ctx, pt, i, rtlHelper, options);\n bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight);\n }\n for (j = 0, jlen = lines.length; j < jlen; ++j) {\n fillLineOfText(lines[j]);\n bodyLineHeight = bodyFont.lineHeight;\n }\n each(bodyItem.after, fillLineOfText);\n }\n xLinePadding = 0;\n bodyLineHeight = bodyFont.lineHeight;\n each(this.afterBody, fillLineOfText);\n pt.y -= bodySpacing;\n }\n drawFooter(pt, ctx, options) {\n const footer = this.footer;\n const length = footer.length;\n let footerFont, i;\n if (length) {\n const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width);\n pt.x = getAlignedX(this, options.footerAlign, options);\n pt.y += options.footerMarginTop;\n ctx.textAlign = rtlHelper.textAlign(options.footerAlign);\n ctx.textBaseline = 'middle';\n footerFont = toFont(options.footerFont);\n ctx.fillStyle = options.footerColor;\n ctx.font = footerFont.string;\n for (i = 0; i < length; ++i) {\n ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2);\n pt.y += footerFont.lineHeight + options.footerSpacing;\n }\n }\n }\n drawBackground(pt, ctx, tooltipSize, options) {\n const {xAlign, yAlign} = this;\n const {x, y} = pt;\n const {width, height} = tooltipSize;\n const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(options.cornerRadius);\n ctx.fillStyle = options.backgroundColor;\n ctx.strokeStyle = options.borderColor;\n ctx.lineWidth = options.borderWidth;\n ctx.beginPath();\n ctx.moveTo(x + topLeft, y);\n if (yAlign === 'top') {\n this.drawCaret(pt, ctx, tooltipSize, options);\n }\n ctx.lineTo(x + width - topRight, y);\n ctx.quadraticCurveTo(x + width, y, x + width, y + topRight);\n if (yAlign === 'center' && xAlign === 'right') {\n this.drawCaret(pt, ctx, tooltipSize, options);\n }\n ctx.lineTo(x + width, y + height - bottomRight);\n ctx.quadraticCurveTo(x + width, y + height, x + width - bottomRight, y + height);\n if (yAlign === 'bottom') {\n this.drawCaret(pt, ctx, tooltipSize, options);\n }\n ctx.lineTo(x + bottomLeft, y + height);\n ctx.quadraticCurveTo(x, y + height, x, y + height - bottomLeft);\n if (yAlign === 'center' && xAlign === 'left') {\n this.drawCaret(pt, ctx, tooltipSize, options);\n }\n ctx.lineTo(x, y + topLeft);\n ctx.quadraticCurveTo(x, y, x + topLeft, y);\n ctx.closePath();\n ctx.fill();\n if (options.borderWidth > 0) {\n ctx.stroke();\n }\n }\n _updateAnimationTarget(options) {\n const chart = this.chart;\n const anims = this.$animations;\n const animX = anims && anims.x;\n const animY = anims && anims.y;\n if (animX || animY) {\n const position = positioners[options.position].call(this, this._active, this._eventPosition);\n if (!position) {\n return;\n }\n const size = this._size = getTooltipSize(this, options);\n const positionAndSize = Object.assign({}, position, this._size);\n const alignment = determineAlignment(chart, options, positionAndSize);\n const point = getBackgroundPoint(options, positionAndSize, alignment, chart);\n if (animX._to !== point.x || animY._to !== point.y) {\n this.xAlign = alignment.xAlign;\n this.yAlign = alignment.yAlign;\n this.width = size.width;\n this.height = size.height;\n this.caretX = position.x;\n this.caretY = position.y;\n this._resolveAnimations().update(this, point);\n }\n }\n }\n _willRender() {\n return !!this.opacity;\n }\n draw(ctx) {\n const options = this.options.setContext(this.getContext());\n let opacity = this.opacity;\n if (!opacity) {\n return;\n }\n this._updateAnimationTarget(options);\n const tooltipSize = {\n width: this.width,\n height: this.height\n };\n const pt = {\n x: this.x,\n y: this.y\n };\n opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity;\n const padding = toPadding(options.padding);\n const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length;\n if (options.enabled && hasTooltipContent) {\n ctx.save();\n ctx.globalAlpha = opacity;\n this.drawBackground(pt, ctx, tooltipSize, options);\n overrideTextDirection(ctx, options.textDirection);\n pt.y += padding.top;\n this.drawTitle(pt, ctx, options);\n this.drawBody(pt, ctx, options);\n this.drawFooter(pt, ctx, options);\n restoreTextDirection(ctx, options.textDirection);\n ctx.restore();\n }\n }\n getActiveElements() {\n return this._active || [];\n }\n setActiveElements(activeElements, eventPosition) {\n const lastActive = this._active;\n const active = activeElements.map(({datasetIndex, index}) => {\n const meta = this.chart.getDatasetMeta(datasetIndex);\n if (!meta) {\n throw new Error('Cannot find a dataset at index ' + datasetIndex);\n }\n return {\n datasetIndex,\n element: meta.data[index],\n index,\n };\n });\n const changed = !_elementsEqual(lastActive, active);\n const positionChanged = this._positionChanged(active, eventPosition);\n if (changed || positionChanged) {\n this._active = active;\n this._eventPosition = eventPosition;\n this._ignoreReplayEvents = true;\n this.update(true);\n }\n }\n handleEvent(e, replay, inChartArea = true) {\n if (replay && this._ignoreReplayEvents) {\n return false;\n }\n this._ignoreReplayEvents = false;\n const options = this.options;\n const lastActive = this._active || [];\n const active = this._getActiveElements(e, lastActive, replay, inChartArea);\n const positionChanged = this._positionChanged(active, e);\n const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;\n if (changed) {\n this._active = active;\n if (options.enabled || options.external) {\n this._eventPosition = {\n x: e.x,\n y: e.y\n };\n this.update(true, replay);\n }\n }\n return changed;\n }\n _getActiveElements(e, lastActive, replay, inChartArea) {\n const options = this.options;\n if (e.type === 'mouseout') {\n return [];\n }\n if (!inChartArea) {\n return lastActive;\n }\n const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay);\n if (options.reverse) {\n active.reverse();\n }\n return active;\n }\n _positionChanged(active, e) {\n const {caretX, caretY, options} = this;\n const position = positioners[options.position].call(this, active, e);\n return position !== false && (caretX !== position.x || caretY !== position.y);\n }\n}\nTooltip.positioners = positioners;\nvar plugin_tooltip = {\n id: 'tooltip',\n _element: Tooltip,\n positioners,\n afterInit(chart, _args, options) {\n if (options) {\n chart.tooltip = new Tooltip({chart, options});\n }\n },\n beforeUpdate(chart, _args, options) {\n if (chart.tooltip) {\n chart.tooltip.initialize(options);\n }\n },\n reset(chart, _args, options) {\n if (chart.tooltip) {\n chart.tooltip.initialize(options);\n }\n },\n afterDraw(chart) {\n const tooltip = chart.tooltip;\n if (tooltip && tooltip._willRender()) {\n const args = {\n tooltip\n };\n if (chart.notifyPlugins('beforeTooltipDraw', args) === false) {\n return;\n }\n tooltip.draw(chart.ctx);\n chart.notifyPlugins('afterTooltipDraw', args);\n }\n },\n afterEvent(chart, args) {\n if (chart.tooltip) {\n const useFinalPosition = args.replay;\n if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) {\n args.changed = true;\n }\n }\n },\n defaults: {\n enabled: true,\n external: null,\n position: 'average',\n backgroundColor: 'rgba(0,0,0,0.8)',\n titleColor: '#fff',\n titleFont: {\n weight: 'bold',\n },\n titleSpacing: 2,\n titleMarginBottom: 6,\n titleAlign: 'left',\n bodyColor: '#fff',\n bodySpacing: 2,\n bodyFont: {\n },\n bodyAlign: 'left',\n footerColor: '#fff',\n footerSpacing: 2,\n footerMarginTop: 6,\n footerFont: {\n weight: 'bold',\n },\n footerAlign: 'left',\n padding: 6,\n caretPadding: 2,\n caretSize: 5,\n cornerRadius: 6,\n boxHeight: (ctx, opts) => opts.bodyFont.size,\n boxWidth: (ctx, opts) => opts.bodyFont.size,\n multiKeyBackground: '#fff',\n displayColors: true,\n boxPadding: 0,\n borderColor: 'rgba(0,0,0,0)',\n borderWidth: 0,\n animation: {\n duration: 400,\n easing: 'easeOutQuart',\n },\n animations: {\n numbers: {\n type: 'number',\n properties: ['x', 'y', 'width', 'height', 'caretX', 'caretY'],\n },\n opacity: {\n easing: 'linear',\n duration: 200\n }\n },\n callbacks: {\n beforeTitle: noop,\n title(tooltipItems) {\n if (tooltipItems.length > 0) {\n const item = tooltipItems[0];\n const labels = item.chart.data.labels;\n const labelCount = labels ? labels.length : 0;\n if (this && this.options && this.options.mode === 'dataset') {\n return item.dataset.label || '';\n } else if (item.label) {\n return item.label;\n } else if (labelCount > 0 && item.dataIndex < labelCount) {\n return labels[item.dataIndex];\n }\n }\n return '';\n },\n afterTitle: noop,\n beforeBody: noop,\n beforeLabel: noop,\n label(tooltipItem) {\n if (this && this.options && this.options.mode === 'dataset') {\n return tooltipItem.label + ': ' + tooltipItem.formattedValue || tooltipItem.formattedValue;\n }\n let label = tooltipItem.dataset.label || '';\n if (label) {\n label += ': ';\n }\n const value = tooltipItem.formattedValue;\n if (!isNullOrUndef(value)) {\n label += value;\n }\n return label;\n },\n labelColor(tooltipItem) {\n const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);\n const options = meta.controller.getStyle(tooltipItem.dataIndex);\n return {\n borderColor: options.borderColor,\n backgroundColor: options.backgroundColor,\n borderWidth: options.borderWidth,\n borderDash: options.borderDash,\n borderDashOffset: options.borderDashOffset,\n borderRadius: 0,\n };\n },\n labelTextColor() {\n return this.options.bodyColor;\n },\n labelPointStyle(tooltipItem) {\n const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex);\n const options = meta.controller.getStyle(tooltipItem.dataIndex);\n return {\n pointStyle: options.pointStyle,\n rotation: options.rotation,\n };\n },\n afterLabel: noop,\n afterBody: noop,\n beforeFooter: noop,\n footer: noop,\n afterFooter: noop\n }\n },\n defaultRoutes: {\n bodyFont: 'font',\n footerFont: 'font',\n titleFont: 'font'\n },\n descriptors: {\n _scriptable: (name) => name !== 'filter' && name !== 'itemSort' && name !== 'external',\n _indexable: false,\n callbacks: {\n _scriptable: false,\n _indexable: false,\n },\n animation: {\n _fallback: false\n },\n animations: {\n _fallback: 'animation'\n }\n },\n additionalOptionScopes: ['interaction']\n};\n\nvar plugins = /*#__PURE__*/Object.freeze({\n__proto__: null,\nDecimation: plugin_decimation,\nFiller: index,\nLegend: plugin_legend,\nSubTitle: plugin_subtitle,\nTitle: plugin_title,\nTooltip: plugin_tooltip\n});\n\nconst addIfString = (labels, raw, index, addedLabels) => {\n if (typeof raw === 'string') {\n index = labels.push(raw) - 1;\n addedLabels.unshift({index, label: raw});\n } else if (isNaN(raw)) {\n index = null;\n }\n return index;\n};\nfunction findOrAddLabel(labels, raw, index, addedLabels) {\n const first = labels.indexOf(raw);\n if (first === -1) {\n return addIfString(labels, raw, index, addedLabels);\n }\n const last = labels.lastIndexOf(raw);\n return first !== last ? index : first;\n}\nconst validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max);\nclass CategoryScale extends Scale {\n constructor(cfg) {\n super(cfg);\n this._startValue = undefined;\n this._valueRange = 0;\n this._addedLabels = [];\n }\n init(scaleOptions) {\n const added = this._addedLabels;\n if (added.length) {\n const labels = this.getLabels();\n for (const {index, label} of added) {\n if (labels[index] === label) {\n labels.splice(index, 1);\n }\n }\n this._addedLabels = [];\n }\n super.init(scaleOptions);\n }\n parse(raw, index) {\n if (isNullOrUndef(raw)) {\n return null;\n }\n const labels = this.getLabels();\n index = isFinite(index) && labels[index] === raw ? index\n : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);\n return validIndex(index, labels.length - 1);\n }\n determineDataLimits() {\n const {minDefined, maxDefined} = this.getUserBounds();\n let {min, max} = this.getMinMax(true);\n if (this.options.bounds === 'ticks') {\n if (!minDefined) {\n min = 0;\n }\n if (!maxDefined) {\n max = this.getLabels().length - 1;\n }\n }\n this.min = min;\n this.max = max;\n }\n buildTicks() {\n const min = this.min;\n const max = this.max;\n const offset = this.options.offset;\n const ticks = [];\n let labels = this.getLabels();\n labels = (min === 0 && max === labels.length - 1) ? labels : labels.slice(min, max + 1);\n this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1);\n this._startValue = this.min - (offset ? 0.5 : 0);\n for (let value = min; value <= max; value++) {\n ticks.push({value});\n }\n return ticks;\n }\n getLabelForValue(value) {\n const labels = this.getLabels();\n if (value >= 0 && value < labels.length) {\n return labels[value];\n }\n return value;\n }\n configure() {\n super.configure();\n if (!this.isHorizontal()) {\n this._reversePixels = !this._reversePixels;\n }\n }\n getPixelForValue(value) {\n if (typeof value !== 'number') {\n value = this.parse(value);\n }\n return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);\n }\n getPixelForTick(index) {\n const ticks = this.ticks;\n if (index < 0 || index > ticks.length - 1) {\n return null;\n }\n return this.getPixelForValue(ticks[index].value);\n }\n getValueForPixel(pixel) {\n return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange);\n }\n getBasePixel() {\n return this.bottom;\n }\n}\nCategoryScale.id = 'category';\nCategoryScale.defaults = {\n ticks: {\n callback: CategoryScale.prototype.getLabelForValue\n }\n};\n\nfunction generateTicks$1(generationOptions, dataRange) {\n const ticks = [];\n const MIN_SPACING = 1e-14;\n const {bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds} = generationOptions;\n const unit = step || 1;\n const maxSpaces = maxTicks - 1;\n const {min: rmin, max: rmax} = dataRange;\n const minDefined = !isNullOrUndef(min);\n const maxDefined = !isNullOrUndef(max);\n const countDefined = !isNullOrUndef(count);\n const minSpacing = (rmax - rmin) / (maxDigits + 1);\n let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit;\n let factor, niceMin, niceMax, numSpaces;\n if (spacing < MIN_SPACING && !minDefined && !maxDefined) {\n return [{value: rmin}, {value: rmax}];\n }\n numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing);\n if (numSpaces > maxSpaces) {\n spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit;\n }\n if (!isNullOrUndef(precision)) {\n factor = Math.pow(10, precision);\n spacing = Math.ceil(spacing * factor) / factor;\n }\n if (bounds === 'ticks') {\n niceMin = Math.floor(rmin / spacing) * spacing;\n niceMax = Math.ceil(rmax / spacing) * spacing;\n } else {\n niceMin = rmin;\n niceMax = rmax;\n }\n if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1000)) {\n numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks));\n spacing = (max - min) / numSpaces;\n niceMin = min;\n niceMax = max;\n } else if (countDefined) {\n niceMin = minDefined ? min : niceMin;\n niceMax = maxDefined ? max : niceMax;\n numSpaces = count - 1;\n spacing = (niceMax - niceMin) / numSpaces;\n } else {\n numSpaces = (niceMax - niceMin) / spacing;\n if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) {\n numSpaces = Math.round(numSpaces);\n } else {\n numSpaces = Math.ceil(numSpaces);\n }\n }\n const decimalPlaces = Math.max(\n _decimalPlaces(spacing),\n _decimalPlaces(niceMin)\n );\n factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision);\n niceMin = Math.round(niceMin * factor) / factor;\n niceMax = Math.round(niceMax * factor) / factor;\n let j = 0;\n if (minDefined) {\n if (includeBounds && niceMin !== min) {\n ticks.push({value: min});\n if (niceMin < min) {\n j++;\n }\n if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) {\n j++;\n }\n } else if (niceMin < min) {\n j++;\n }\n }\n for (; j < numSpaces; ++j) {\n ticks.push({value: Math.round((niceMin + j * spacing) * factor) / factor});\n }\n if (maxDefined && includeBounds && niceMax !== max) {\n if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) {\n ticks[ticks.length - 1].value = max;\n } else {\n ticks.push({value: max});\n }\n } else if (!maxDefined || niceMax === max) {\n ticks.push({value: niceMax});\n }\n return ticks;\n}\nfunction relativeLabelSize(value, minSpacing, {horizontal, minRotation}) {\n const rad = toRadians(minRotation);\n const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 0.001;\n const length = 0.75 * minSpacing * ('' + value).length;\n return Math.min(minSpacing / ratio, length);\n}\nclass LinearScaleBase extends Scale {\n constructor(cfg) {\n super(cfg);\n this.start = undefined;\n this.end = undefined;\n this._startValue = undefined;\n this._endValue = undefined;\n this._valueRange = 0;\n }\n parse(raw, index) {\n if (isNullOrUndef(raw)) {\n return null;\n }\n if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) {\n return null;\n }\n return +raw;\n }\n handleTickRangeOptions() {\n const {beginAtZero} = this.options;\n const {minDefined, maxDefined} = this.getUserBounds();\n let {min, max} = this;\n const setMin = v => (min = minDefined ? min : v);\n const setMax = v => (max = maxDefined ? max : v);\n if (beginAtZero) {\n const minSign = sign(min);\n const maxSign = sign(max);\n if (minSign < 0 && maxSign < 0) {\n setMax(0);\n } else if (minSign > 0 && maxSign > 0) {\n setMin(0);\n }\n }\n if (min === max) {\n let offset = 1;\n if (max >= Number.MAX_SAFE_INTEGER || min <= Number.MIN_SAFE_INTEGER) {\n offset = Math.abs(max * 0.05);\n }\n setMax(max + offset);\n if (!beginAtZero) {\n setMin(min - offset);\n }\n }\n this.min = min;\n this.max = max;\n }\n getTickLimit() {\n const tickOpts = this.options.ticks;\n let {maxTicksLimit, stepSize} = tickOpts;\n let maxTicks;\n if (stepSize) {\n maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1;\n if (maxTicks > 1000) {\n console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`);\n maxTicks = 1000;\n }\n } else {\n maxTicks = this.computeTickLimit();\n maxTicksLimit = maxTicksLimit || 11;\n }\n if (maxTicksLimit) {\n maxTicks = Math.min(maxTicksLimit, maxTicks);\n }\n return maxTicks;\n }\n computeTickLimit() {\n return Number.POSITIVE_INFINITY;\n }\n buildTicks() {\n const opts = this.options;\n const tickOpts = opts.ticks;\n let maxTicks = this.getTickLimit();\n maxTicks = Math.max(2, maxTicks);\n const numericGeneratorOptions = {\n maxTicks,\n bounds: opts.bounds,\n min: opts.min,\n max: opts.max,\n precision: tickOpts.precision,\n step: tickOpts.stepSize,\n count: tickOpts.count,\n maxDigits: this._maxDigits(),\n horizontal: this.isHorizontal(),\n minRotation: tickOpts.minRotation || 0,\n includeBounds: tickOpts.includeBounds !== false\n };\n const dataRange = this._range || this;\n const ticks = generateTicks$1(numericGeneratorOptions, dataRange);\n if (opts.bounds === 'ticks') {\n _setMinAndMaxByKey(ticks, this, 'value');\n }\n if (opts.reverse) {\n ticks.reverse();\n this.start = this.max;\n this.end = this.min;\n } else {\n this.start = this.min;\n this.end = this.max;\n }\n return ticks;\n }\n configure() {\n const ticks = this.ticks;\n let start = this.min;\n let end = this.max;\n super.configure();\n if (this.options.offset && ticks.length) {\n const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2;\n start -= offset;\n end += offset;\n }\n this._startValue = start;\n this._endValue = end;\n this._valueRange = end - start;\n }\n getLabelForValue(value) {\n return formatNumber(value, this.chart.options.locale, this.options.ticks.format);\n }\n}\n\nclass LinearScale extends LinearScaleBase {\n determineDataLimits() {\n const {min, max} = this.getMinMax(true);\n this.min = isNumberFinite(min) ? min : 0;\n this.max = isNumberFinite(max) ? max : 1;\n this.handleTickRangeOptions();\n }\n computeTickLimit() {\n const horizontal = this.isHorizontal();\n const length = horizontal ? this.width : this.height;\n const minRotation = toRadians(this.options.ticks.minRotation);\n const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 0.001;\n const tickFont = this._resolveTickFontOptions(0);\n return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio));\n }\n getPixelForValue(value) {\n return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange);\n }\n getValueForPixel(pixel) {\n return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange;\n }\n}\nLinearScale.id = 'linear';\nLinearScale.defaults = {\n ticks: {\n callback: Ticks.formatters.numeric\n }\n};\n\nfunction isMajor(tickVal) {\n const remain = tickVal / (Math.pow(10, Math.floor(log10(tickVal))));\n return remain === 1;\n}\nfunction generateTicks(generationOptions, dataRange) {\n const endExp = Math.floor(log10(dataRange.max));\n const endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp));\n const ticks = [];\n let tickVal = finiteOrDefault(generationOptions.min, Math.pow(10, Math.floor(log10(dataRange.min))));\n let exp = Math.floor(log10(tickVal));\n let significand = Math.floor(tickVal / Math.pow(10, exp));\n let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1;\n do {\n ticks.push({value: tickVal, major: isMajor(tickVal)});\n ++significand;\n if (significand === 10) {\n significand = 1;\n ++exp;\n precision = exp >= 0 ? 1 : precision;\n }\n tickVal = Math.round(significand * Math.pow(10, exp) * precision) / precision;\n } while (exp < endExp || (exp === endExp && significand < endSignificand));\n const lastTick = finiteOrDefault(generationOptions.max, tickVal);\n ticks.push({value: lastTick, major: isMajor(tickVal)});\n return ticks;\n}\nclass LogarithmicScale extends Scale {\n constructor(cfg) {\n super(cfg);\n this.start = undefined;\n this.end = undefined;\n this._startValue = undefined;\n this._valueRange = 0;\n }\n parse(raw, index) {\n const value = LinearScaleBase.prototype.parse.apply(this, [raw, index]);\n if (value === 0) {\n this._zero = true;\n return undefined;\n }\n return isNumberFinite(value) && value > 0 ? value : null;\n }\n determineDataLimits() {\n const {min, max} = this.getMinMax(true);\n this.min = isNumberFinite(min) ? Math.max(0, min) : null;\n this.max = isNumberFinite(max) ? Math.max(0, max) : null;\n if (this.options.beginAtZero) {\n this._zero = true;\n }\n this.handleTickRangeOptions();\n }\n handleTickRangeOptions() {\n const {minDefined, maxDefined} = this.getUserBounds();\n let min = this.min;\n let max = this.max;\n const setMin = v => (min = minDefined ? min : v);\n const setMax = v => (max = maxDefined ? max : v);\n const exp = (v, m) => Math.pow(10, Math.floor(log10(v)) + m);\n if (min === max) {\n if (min <= 0) {\n setMin(1);\n setMax(10);\n } else {\n setMin(exp(min, -1));\n setMax(exp(max, +1));\n }\n }\n if (min <= 0) {\n setMin(exp(max, -1));\n }\n if (max <= 0) {\n setMax(exp(min, +1));\n }\n if (this._zero && this.min !== this._suggestedMin && min === exp(this.min, 0)) {\n setMin(exp(min, -1));\n }\n this.min = min;\n this.max = max;\n }\n buildTicks() {\n const opts = this.options;\n const generationOptions = {\n min: this._userMin,\n max: this._userMax\n };\n const ticks = generateTicks(generationOptions, this);\n if (opts.bounds === 'ticks') {\n _setMinAndMaxByKey(ticks, this, 'value');\n }\n if (opts.reverse) {\n ticks.reverse();\n this.start = this.max;\n this.end = this.min;\n } else {\n this.start = this.min;\n this.end = this.max;\n }\n return ticks;\n }\n getLabelForValue(value) {\n return value === undefined\n ? '0'\n : formatNumber(value, this.chart.options.locale, this.options.ticks.format);\n }\n configure() {\n const start = this.min;\n super.configure();\n this._startValue = log10(start);\n this._valueRange = log10(this.max) - log10(start);\n }\n getPixelForValue(value) {\n if (value === undefined || value === 0) {\n value = this.min;\n }\n if (value === null || isNaN(value)) {\n return NaN;\n }\n return this.getPixelForDecimal(value === this.min\n ? 0\n : (log10(value) - this._startValue) / this._valueRange);\n }\n getValueForPixel(pixel) {\n const decimal = this.getDecimalForPixel(pixel);\n return Math.pow(10, this._startValue + decimal * this._valueRange);\n }\n}\nLogarithmicScale.id = 'logarithmic';\nLogarithmicScale.defaults = {\n ticks: {\n callback: Ticks.formatters.logarithmic,\n major: {\n enabled: true\n }\n }\n};\n\nfunction getTickBackdropHeight(opts) {\n const tickOpts = opts.ticks;\n if (tickOpts.display && opts.display) {\n const padding = toPadding(tickOpts.backdropPadding);\n return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + padding.height;\n }\n return 0;\n}\nfunction measureLabelSize(ctx, font, label) {\n label = isArray(label) ? label : [label];\n return {\n w: _longestText(ctx, font.string, label),\n h: label.length * font.lineHeight\n };\n}\nfunction determineLimits(angle, pos, size, min, max) {\n if (angle === min || angle === max) {\n return {\n start: pos - (size / 2),\n end: pos + (size / 2)\n };\n } else if (angle < min || angle > max) {\n return {\n start: pos - size,\n end: pos\n };\n }\n return {\n start: pos,\n end: pos + size\n };\n}\nfunction fitWithPointLabels(scale) {\n const orig = {\n l: scale.left + scale._padding.left,\n r: scale.right - scale._padding.right,\n t: scale.top + scale._padding.top,\n b: scale.bottom - scale._padding.bottom\n };\n const limits = Object.assign({}, orig);\n const labelSizes = [];\n const padding = [];\n const valueCount = scale._pointLabels.length;\n const pointLabelOpts = scale.options.pointLabels;\n const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;\n for (let i = 0; i < valueCount; i++) {\n const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i));\n padding[i] = opts.padding;\n const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle);\n const plFont = toFont(opts.font);\n const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]);\n labelSizes[i] = textSize;\n const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle);\n const angle = Math.round(toDegrees(angleRadians));\n const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);\n const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);\n updateLimits(limits, orig, angleRadians, hLimits, vLimits);\n }\n scale.setCenterPoint(\n orig.l - limits.l,\n limits.r - orig.r,\n orig.t - limits.t,\n limits.b - orig.b\n );\n scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);\n}\nfunction updateLimits(limits, orig, angle, hLimits, vLimits) {\n const sin = Math.abs(Math.sin(angle));\n const cos = Math.abs(Math.cos(angle));\n let x = 0;\n let y = 0;\n if (hLimits.start < orig.l) {\n x = (orig.l - hLimits.start) / sin;\n limits.l = Math.min(limits.l, orig.l - x);\n } else if (hLimits.end > orig.r) {\n x = (hLimits.end - orig.r) / sin;\n limits.r = Math.max(limits.r, orig.r + x);\n }\n if (vLimits.start < orig.t) {\n y = (orig.t - vLimits.start) / cos;\n limits.t = Math.min(limits.t, orig.t - y);\n } else if (vLimits.end > orig.b) {\n y = (vLimits.end - orig.b) / cos;\n limits.b = Math.max(limits.b, orig.b + y);\n }\n}\nfunction buildPointLabelItems(scale, labelSizes, padding) {\n const items = [];\n const valueCount = scale._pointLabels.length;\n const opts = scale.options;\n const extra = getTickBackdropHeight(opts) / 2;\n const outerDistance = scale.drawingArea;\n const additionalAngle = opts.pointLabels.centerPointLabels ? PI / valueCount : 0;\n for (let i = 0; i < valueCount; i++) {\n const pointLabelPosition = scale.getPointPosition(i, outerDistance + extra + padding[i], additionalAngle);\n const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));\n const size = labelSizes[i];\n const y = yForAngle(pointLabelPosition.y, size.h, angle);\n const textAlign = getTextAlignForAngle(angle);\n const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign);\n items.push({\n x: pointLabelPosition.x,\n y,\n textAlign,\n left,\n top: y,\n right: left + size.w,\n bottom: y + size.h\n });\n }\n return items;\n}\nfunction getTextAlignForAngle(angle) {\n if (angle === 0 || angle === 180) {\n return 'center';\n } else if (angle < 180) {\n return 'left';\n }\n return 'right';\n}\nfunction leftForTextAlign(x, w, align) {\n if (align === 'right') {\n x -= w;\n } else if (align === 'center') {\n x -= (w / 2);\n }\n return x;\n}\nfunction yForAngle(y, h, angle) {\n if (angle === 90 || angle === 270) {\n y -= (h / 2);\n } else if (angle > 270 || angle < 90) {\n y -= h;\n }\n return y;\n}\nfunction drawPointLabels(scale, labelCount) {\n const {ctx, options: {pointLabels}} = scale;\n for (let i = labelCount - 1; i >= 0; i--) {\n const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i));\n const plFont = toFont(optsAtIndex.font);\n const {x, y, textAlign, left, top, right, bottom} = scale._pointLabelItems[i];\n const {backdropColor} = optsAtIndex;\n if (!isNullOrUndef(backdropColor)) {\n const borderRadius = toTRBLCorners(optsAtIndex.borderRadius);\n const padding = toPadding(optsAtIndex.backdropPadding);\n ctx.fillStyle = backdropColor;\n const backdropLeft = left - padding.left;\n const backdropTop = top - padding.top;\n const backdropWidth = right - left + padding.width;\n const backdropHeight = bottom - top + padding.height;\n if (Object.values(borderRadius).some(v => v !== 0)) {\n ctx.beginPath();\n addRoundedRectPath(ctx, {\n x: backdropLeft,\n y: backdropTop,\n w: backdropWidth,\n h: backdropHeight,\n radius: borderRadius,\n });\n ctx.fill();\n } else {\n ctx.fillRect(backdropLeft, backdropTop, backdropWidth, backdropHeight);\n }\n }\n renderText(\n ctx,\n scale._pointLabels[i],\n x,\n y + (plFont.lineHeight / 2),\n plFont,\n {\n color: optsAtIndex.color,\n textAlign: textAlign,\n textBaseline: 'middle'\n }\n );\n }\n}\nfunction pathRadiusLine(scale, radius, circular, labelCount) {\n const {ctx} = scale;\n if (circular) {\n ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU);\n } else {\n let pointPosition = scale.getPointPosition(0, radius);\n ctx.moveTo(pointPosition.x, pointPosition.y);\n for (let i = 1; i < labelCount; i++) {\n pointPosition = scale.getPointPosition(i, radius);\n ctx.lineTo(pointPosition.x, pointPosition.y);\n }\n }\n}\nfunction drawRadiusLine(scale, gridLineOpts, radius, labelCount) {\n const ctx = scale.ctx;\n const circular = gridLineOpts.circular;\n const {color, lineWidth} = gridLineOpts;\n if ((!circular && !labelCount) || !color || !lineWidth || radius < 0) {\n return;\n }\n ctx.save();\n ctx.strokeStyle = color;\n ctx.lineWidth = lineWidth;\n ctx.setLineDash(gridLineOpts.borderDash);\n ctx.lineDashOffset = gridLineOpts.borderDashOffset;\n ctx.beginPath();\n pathRadiusLine(scale, radius, circular, labelCount);\n ctx.closePath();\n ctx.stroke();\n ctx.restore();\n}\nfunction createPointLabelContext(parent, index, label) {\n return createContext(parent, {\n label,\n index,\n type: 'pointLabel'\n });\n}\nclass RadialLinearScale extends LinearScaleBase {\n constructor(cfg) {\n super(cfg);\n this.xCenter = undefined;\n this.yCenter = undefined;\n this.drawingArea = undefined;\n this._pointLabels = [];\n this._pointLabelItems = [];\n }\n setDimensions() {\n const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);\n const w = this.width = this.maxWidth - padding.width;\n const h = this.height = this.maxHeight - padding.height;\n this.xCenter = Math.floor(this.left + w / 2 + padding.left);\n this.yCenter = Math.floor(this.top + h / 2 + padding.top);\n this.drawingArea = Math.floor(Math.min(w, h) / 2);\n }\n determineDataLimits() {\n const {min, max} = this.getMinMax(false);\n this.min = isNumberFinite(min) && !isNaN(min) ? min : 0;\n this.max = isNumberFinite(max) && !isNaN(max) ? max : 0;\n this.handleTickRangeOptions();\n }\n computeTickLimit() {\n return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options));\n }\n generateTickLabels(ticks) {\n LinearScaleBase.prototype.generateTickLabels.call(this, ticks);\n this._pointLabels = this.getLabels()\n .map((value, index) => {\n const label = callback(this.options.pointLabels.callback, [value, index], this);\n return label || label === 0 ? label : '';\n })\n .filter((v, i) => this.chart.getDataVisibility(i));\n }\n fit() {\n const opts = this.options;\n if (opts.display && opts.pointLabels.display) {\n fitWithPointLabels(this);\n } else {\n this.setCenterPoint(0, 0, 0, 0);\n }\n }\n setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {\n this.xCenter += Math.floor((leftMovement - rightMovement) / 2);\n this.yCenter += Math.floor((topMovement - bottomMovement) / 2);\n this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));\n }\n getIndexAngle(index) {\n const angleMultiplier = TAU / (this._pointLabels.length || 1);\n const startAngle = this.options.startAngle || 0;\n return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));\n }\n getDistanceFromCenterForValue(value) {\n if (isNullOrUndef(value)) {\n return NaN;\n }\n const scalingFactor = this.drawingArea / (this.max - this.min);\n if (this.options.reverse) {\n return (this.max - value) * scalingFactor;\n }\n return (value - this.min) * scalingFactor;\n }\n getValueForDistanceFromCenter(distance) {\n if (isNullOrUndef(distance)) {\n return NaN;\n }\n const scaledDistance = distance / (this.drawingArea / (this.max - this.min));\n return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance;\n }\n getPointLabelContext(index) {\n const pointLabels = this._pointLabels || [];\n if (index >= 0 && index < pointLabels.length) {\n const pointLabel = pointLabels[index];\n return createPointLabelContext(this.getContext(), index, pointLabel);\n }\n }\n getPointPosition(index, distanceFromCenter, additionalAngle = 0) {\n const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;\n return {\n x: Math.cos(angle) * distanceFromCenter + this.xCenter,\n y: Math.sin(angle) * distanceFromCenter + this.yCenter,\n angle\n };\n }\n getPointPositionForValue(index, value) {\n return this.getPointPosition(index, this.getDistanceFromCenterForValue(value));\n }\n getBasePosition(index) {\n return this.getPointPositionForValue(index || 0, this.getBaseValue());\n }\n getPointLabelPosition(index) {\n const {left, top, right, bottom} = this._pointLabelItems[index];\n return {\n left,\n top,\n right,\n bottom,\n };\n }\n drawBackground() {\n const {backgroundColor, grid: {circular}} = this.options;\n if (backgroundColor) {\n const ctx = this.ctx;\n ctx.save();\n ctx.beginPath();\n pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);\n ctx.closePath();\n ctx.fillStyle = backgroundColor;\n ctx.fill();\n ctx.restore();\n }\n }\n drawGrid() {\n const ctx = this.ctx;\n const opts = this.options;\n const {angleLines, grid} = opts;\n const labelCount = this._pointLabels.length;\n let i, offset, position;\n if (opts.pointLabels.display) {\n drawPointLabels(this, labelCount);\n }\n if (grid.display) {\n this.ticks.forEach((tick, index) => {\n if (index !== 0) {\n offset = this.getDistanceFromCenterForValue(tick.value);\n const optsAtIndex = grid.setContext(this.getContext(index - 1));\n drawRadiusLine(this, optsAtIndex, offset, labelCount);\n }\n });\n }\n if (angleLines.display) {\n ctx.save();\n for (i = labelCount - 1; i >= 0; i--) {\n const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i));\n const {color, lineWidth} = optsAtIndex;\n if (!lineWidth || !color) {\n continue;\n }\n ctx.lineWidth = lineWidth;\n ctx.strokeStyle = color;\n ctx.setLineDash(optsAtIndex.borderDash);\n ctx.lineDashOffset = optsAtIndex.borderDashOffset;\n offset = this.getDistanceFromCenterForValue(opts.ticks.reverse ? this.min : this.max);\n position = this.getPointPosition(i, offset);\n ctx.beginPath();\n ctx.moveTo(this.xCenter, this.yCenter);\n ctx.lineTo(position.x, position.y);\n ctx.stroke();\n }\n ctx.restore();\n }\n }\n drawBorder() {}\n drawLabels() {\n const ctx = this.ctx;\n const opts = this.options;\n const tickOpts = opts.ticks;\n if (!tickOpts.display) {\n return;\n }\n const startAngle = this.getIndexAngle(0);\n let offset, width;\n ctx.save();\n ctx.translate(this.xCenter, this.yCenter);\n ctx.rotate(startAngle);\n ctx.textAlign = 'center';\n ctx.textBaseline = 'middle';\n this.ticks.forEach((tick, index) => {\n if (index === 0 && !opts.reverse) {\n return;\n }\n const optsAtIndex = tickOpts.setContext(this.getContext(index));\n const tickFont = toFont(optsAtIndex.font);\n offset = this.getDistanceFromCenterForValue(this.ticks[index].value);\n if (optsAtIndex.showLabelBackdrop) {\n ctx.font = tickFont.string;\n width = ctx.measureText(tick.label).width;\n ctx.fillStyle = optsAtIndex.backdropColor;\n const padding = toPadding(optsAtIndex.backdropPadding);\n ctx.fillRect(\n -width / 2 - padding.left,\n -offset - tickFont.size / 2 - padding.top,\n width + padding.width,\n tickFont.size + padding.height\n );\n }\n renderText(ctx, tick.label, 0, -offset, tickFont, {\n color: optsAtIndex.color,\n });\n });\n ctx.restore();\n }\n drawTitle() {}\n}\nRadialLinearScale.id = 'radialLinear';\nRadialLinearScale.defaults = {\n display: true,\n animate: true,\n position: 'chartArea',\n angleLines: {\n display: true,\n lineWidth: 1,\n borderDash: [],\n borderDashOffset: 0.0\n },\n grid: {\n circular: false\n },\n startAngle: 0,\n ticks: {\n showLabelBackdrop: true,\n callback: Ticks.formatters.numeric\n },\n pointLabels: {\n backdropColor: undefined,\n backdropPadding: 2,\n display: true,\n font: {\n size: 10\n },\n callback(label) {\n return label;\n },\n padding: 5,\n centerPointLabels: false\n }\n};\nRadialLinearScale.defaultRoutes = {\n 'angleLines.color': 'borderColor',\n 'pointLabels.color': 'color',\n 'ticks.color': 'color'\n};\nRadialLinearScale.descriptors = {\n angleLines: {\n _fallback: 'grid'\n }\n};\n\nconst INTERVALS = {\n millisecond: {common: true, size: 1, steps: 1000},\n second: {common: true, size: 1000, steps: 60},\n minute: {common: true, size: 60000, steps: 60},\n hour: {common: true, size: 3600000, steps: 24},\n day: {common: true, size: 86400000, steps: 30},\n week: {common: false, size: 604800000, steps: 4},\n month: {common: true, size: 2.628e9, steps: 12},\n quarter: {common: false, size: 7.884e9, steps: 4},\n year: {common: true, size: 3.154e10}\n};\nconst UNITS = (Object.keys(INTERVALS));\nfunction sorter(a, b) {\n return a - b;\n}\nfunction parse(scale, input) {\n if (isNullOrUndef(input)) {\n return null;\n }\n const adapter = scale._adapter;\n const {parser, round, isoWeekday} = scale._parseOpts;\n let value = input;\n if (typeof parser === 'function') {\n value = parser(value);\n }\n if (!isNumberFinite(value)) {\n value = typeof parser === 'string'\n ? adapter.parse(value, parser)\n : adapter.parse(value);\n }\n if (value === null) {\n return null;\n }\n if (round) {\n value = round === 'week' && (isNumber(isoWeekday) || isoWeekday === true)\n ? adapter.startOf(value, 'isoWeek', isoWeekday)\n : adapter.startOf(value, round);\n }\n return +value;\n}\nfunction determineUnitForAutoTicks(minUnit, min, max, capacity) {\n const ilen = UNITS.length;\n for (let i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) {\n const interval = INTERVALS[UNITS[i]];\n const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER;\n if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) {\n return UNITS[i];\n }\n }\n return UNITS[ilen - 1];\n}\nfunction determineUnitForFormatting(scale, numTicks, minUnit, min, max) {\n for (let i = UNITS.length - 1; i >= UNITS.indexOf(minUnit); i--) {\n const unit = UNITS[i];\n if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) {\n return unit;\n }\n }\n return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0];\n}\nfunction determineMajorUnit(unit) {\n for (let i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) {\n if (INTERVALS[UNITS[i]].common) {\n return UNITS[i];\n }\n }\n}\nfunction addTick(ticks, time, timestamps) {\n if (!timestamps) {\n ticks[time] = true;\n } else if (timestamps.length) {\n const {lo, hi} = _lookup(timestamps, time);\n const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi];\n ticks[timestamp] = true;\n }\n}\nfunction setMajorTicks(scale, ticks, map, majorUnit) {\n const adapter = scale._adapter;\n const first = +adapter.startOf(ticks[0].value, majorUnit);\n const last = ticks[ticks.length - 1].value;\n let major, index;\n for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) {\n index = map[major];\n if (index >= 0) {\n ticks[index].major = true;\n }\n }\n return ticks;\n}\nfunction ticksFromTimestamps(scale, values, majorUnit) {\n const ticks = [];\n const map = {};\n const ilen = values.length;\n let i, value;\n for (i = 0; i < ilen; ++i) {\n value = values[i];\n map[value] = i;\n ticks.push({\n value,\n major: false\n });\n }\n return (ilen === 0 || !majorUnit) ? ticks : setMajorTicks(scale, ticks, map, majorUnit);\n}\nclass TimeScale extends Scale {\n constructor(props) {\n super(props);\n this._cache = {\n data: [],\n labels: [],\n all: []\n };\n this._unit = 'day';\n this._majorUnit = undefined;\n this._offsets = {};\n this._normalized = false;\n this._parseOpts = undefined;\n }\n init(scaleOpts, opts) {\n const time = scaleOpts.time || (scaleOpts.time = {});\n const adapter = this._adapter = new adapters._date(scaleOpts.adapters.date);\n mergeIf(time.displayFormats, adapter.formats());\n this._parseOpts = {\n parser: time.parser,\n round: time.round,\n isoWeekday: time.isoWeekday\n };\n super.init(scaleOpts);\n this._normalized = opts.normalized;\n }\n parse(raw, index) {\n if (raw === undefined) {\n return null;\n }\n return parse(this, raw);\n }\n beforeLayout() {\n super.beforeLayout();\n this._cache = {\n data: [],\n labels: [],\n all: []\n };\n }\n determineDataLimits() {\n const options = this.options;\n const adapter = this._adapter;\n const unit = options.time.unit || 'day';\n let {min, max, minDefined, maxDefined} = this.getUserBounds();\n function _applyBounds(bounds) {\n if (!minDefined && !isNaN(bounds.min)) {\n min = Math.min(min, bounds.min);\n }\n if (!maxDefined && !isNaN(bounds.max)) {\n max = Math.max(max, bounds.max);\n }\n }\n if (!minDefined || !maxDefined) {\n _applyBounds(this._getLabelBounds());\n if (options.bounds !== 'ticks' || options.ticks.source !== 'labels') {\n _applyBounds(this.getMinMax(false));\n }\n }\n min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit);\n max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1;\n this.min = Math.min(min, max - 1);\n this.max = Math.max(min + 1, max);\n }\n _getLabelBounds() {\n const arr = this.getLabelTimestamps();\n let min = Number.POSITIVE_INFINITY;\n let max = Number.NEGATIVE_INFINITY;\n if (arr.length) {\n min = arr[0];\n max = arr[arr.length - 1];\n }\n return {min, max};\n }\n buildTicks() {\n const options = this.options;\n const timeOpts = options.time;\n const tickOpts = options.ticks;\n const timestamps = tickOpts.source === 'labels' ? this.getLabelTimestamps() : this._generate();\n if (options.bounds === 'ticks' && timestamps.length) {\n this.min = this._userMin || timestamps[0];\n this.max = this._userMax || timestamps[timestamps.length - 1];\n }\n const min = this.min;\n const max = this.max;\n const ticks = _filterBetween(timestamps, min, max);\n this._unit = timeOpts.unit || (tickOpts.autoSkip\n ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min))\n : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max));\n this._majorUnit = !tickOpts.major.enabled || this._unit === 'year' ? undefined\n : determineMajorUnit(this._unit);\n this.initOffsets(timestamps);\n if (options.reverse) {\n ticks.reverse();\n }\n return ticksFromTimestamps(this, ticks, this._majorUnit);\n }\n afterAutoSkip() {\n if (this.options.offsetAfterAutoskip) {\n this.initOffsets(this.ticks.map(tick => +tick.value));\n }\n }\n initOffsets(timestamps) {\n let start = 0;\n let end = 0;\n let first, last;\n if (this.options.offset && timestamps.length) {\n first = this.getDecimalForValue(timestamps[0]);\n if (timestamps.length === 1) {\n start = 1 - first;\n } else {\n start = (this.getDecimalForValue(timestamps[1]) - first) / 2;\n }\n last = this.getDecimalForValue(timestamps[timestamps.length - 1]);\n if (timestamps.length === 1) {\n end = last;\n } else {\n end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2;\n }\n }\n const limit = timestamps.length < 3 ? 0.5 : 0.25;\n start = _limitValue(start, 0, limit);\n end = _limitValue(end, 0, limit);\n this._offsets = {start, end, factor: 1 / (start + 1 + end)};\n }\n _generate() {\n const adapter = this._adapter;\n const min = this.min;\n const max = this.max;\n const options = this.options;\n const timeOpts = options.time;\n const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min));\n const stepSize = valueOrDefault(timeOpts.stepSize, 1);\n const weekday = minor === 'week' ? timeOpts.isoWeekday : false;\n const hasWeekday = isNumber(weekday) || weekday === true;\n const ticks = {};\n let first = min;\n let time, count;\n if (hasWeekday) {\n first = +adapter.startOf(first, 'isoWeek', weekday);\n }\n first = +adapter.startOf(first, hasWeekday ? 'day' : minor);\n if (adapter.diff(max, min, minor) > 100000 * stepSize) {\n throw new Error(min + ' and ' + max + ' are too far apart with stepSize of ' + stepSize + ' ' + minor);\n }\n const timestamps = options.ticks.source === 'data' && this.getDataTimestamps();\n for (time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++) {\n addTick(ticks, time, timestamps);\n }\n if (time === max || options.bounds === 'ticks' || count === 1) {\n addTick(ticks, time, timestamps);\n }\n return Object.keys(ticks).sort((a, b) => a - b).map(x => +x);\n }\n getLabelForValue(value) {\n const adapter = this._adapter;\n const timeOpts = this.options.time;\n if (timeOpts.tooltipFormat) {\n return adapter.format(value, timeOpts.tooltipFormat);\n }\n return adapter.format(value, timeOpts.displayFormats.datetime);\n }\n _tickFormatFunction(time, index, ticks, format) {\n const options = this.options;\n const formats = options.time.displayFormats;\n const unit = this._unit;\n const majorUnit = this._majorUnit;\n const minorFormat = unit && formats[unit];\n const majorFormat = majorUnit && formats[majorUnit];\n const tick = ticks[index];\n const major = majorUnit && majorFormat && tick && tick.major;\n const label = this._adapter.format(time, format || (major ? majorFormat : minorFormat));\n const formatter = options.ticks.callback;\n return formatter ? callback(formatter, [label, index, ticks], this) : label;\n }\n generateTickLabels(ticks) {\n let i, ilen, tick;\n for (i = 0, ilen = ticks.length; i < ilen; ++i) {\n tick = ticks[i];\n tick.label = this._tickFormatFunction(tick.value, i, ticks);\n }\n }\n getDecimalForValue(value) {\n return value === null ? NaN : (value - this.min) / (this.max - this.min);\n }\n getPixelForValue(value) {\n const offsets = this._offsets;\n const pos = this.getDecimalForValue(value);\n return this.getPixelForDecimal((offsets.start + pos) * offsets.factor);\n }\n getValueForPixel(pixel) {\n const offsets = this._offsets;\n const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;\n return this.min + pos * (this.max - this.min);\n }\n _getLabelSize(label) {\n const ticksOpts = this.options.ticks;\n const tickLabelWidth = this.ctx.measureText(label).width;\n const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation);\n const cosRotation = Math.cos(angle);\n const sinRotation = Math.sin(angle);\n const tickFontSize = this._resolveTickFontOptions(0).size;\n return {\n w: (tickLabelWidth * cosRotation) + (tickFontSize * sinRotation),\n h: (tickLabelWidth * sinRotation) + (tickFontSize * cosRotation)\n };\n }\n _getLabelCapacity(exampleTime) {\n const timeOpts = this.options.time;\n const displayFormats = timeOpts.displayFormats;\n const format = displayFormats[timeOpts.unit] || displayFormats.millisecond;\n const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [exampleTime], this._majorUnit), format);\n const size = this._getLabelSize(exampleLabel);\n const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1;\n return capacity > 0 ? capacity : 1;\n }\n getDataTimestamps() {\n let timestamps = this._cache.data || [];\n let i, ilen;\n if (timestamps.length) {\n return timestamps;\n }\n const metas = this.getMatchingVisibleMetas();\n if (this._normalized && metas.length) {\n return (this._cache.data = metas[0].controller.getAllParsedValues(this));\n }\n for (i = 0, ilen = metas.length; i < ilen; ++i) {\n timestamps = timestamps.concat(metas[i].controller.getAllParsedValues(this));\n }\n return (this._cache.data = this.normalize(timestamps));\n }\n getLabelTimestamps() {\n const timestamps = this._cache.labels || [];\n let i, ilen;\n if (timestamps.length) {\n return timestamps;\n }\n const labels = this.getLabels();\n for (i = 0, ilen = labels.length; i < ilen; ++i) {\n timestamps.push(parse(this, labels[i]));\n }\n return (this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps));\n }\n normalize(values) {\n return _arrayUnique(values.sort(sorter));\n }\n}\nTimeScale.id = 'time';\nTimeScale.defaults = {\n bounds: 'data',\n adapters: {},\n time: {\n parser: false,\n unit: false,\n round: false,\n isoWeekday: false,\n minUnit: 'millisecond',\n displayFormats: {}\n },\n ticks: {\n source: 'auto',\n major: {\n enabled: false\n }\n }\n};\n\nfunction interpolate(table, val, reverse) {\n let lo = 0;\n let hi = table.length - 1;\n let prevSource, nextSource, prevTarget, nextTarget;\n if (reverse) {\n if (val >= table[lo].pos && val <= table[hi].pos) {\n ({lo, hi} = _lookupByKey(table, 'pos', val));\n }\n ({pos: prevSource, time: prevTarget} = table[lo]);\n ({pos: nextSource, time: nextTarget} = table[hi]);\n } else {\n if (val >= table[lo].time && val <= table[hi].time) {\n ({lo, hi} = _lookupByKey(table, 'time', val));\n }\n ({time: prevSource, pos: prevTarget} = table[lo]);\n ({time: nextSource, pos: nextTarget} = table[hi]);\n }\n const span = nextSource - prevSource;\n return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget;\n}\nclass TimeSeriesScale extends TimeScale {\n constructor(props) {\n super(props);\n this._table = [];\n this._minPos = undefined;\n this._tableRange = undefined;\n }\n initOffsets() {\n const timestamps = this._getTimestampsForTable();\n const table = this._table = this.buildLookupTable(timestamps);\n this._minPos = interpolate(table, this.min);\n this._tableRange = interpolate(table, this.max) - this._minPos;\n super.initOffsets(timestamps);\n }\n buildLookupTable(timestamps) {\n const {min, max} = this;\n const items = [];\n const table = [];\n let i, ilen, prev, curr, next;\n for (i = 0, ilen = timestamps.length; i < ilen; ++i) {\n curr = timestamps[i];\n if (curr >= min && curr <= max) {\n items.push(curr);\n }\n }\n if (items.length < 2) {\n return [\n {time: min, pos: 0},\n {time: max, pos: 1}\n ];\n }\n for (i = 0, ilen = items.length; i < ilen; ++i) {\n next = items[i + 1];\n prev = items[i - 1];\n curr = items[i];\n if (Math.round((next + prev) / 2) !== curr) {\n table.push({time: curr, pos: i / (ilen - 1)});\n }\n }\n return table;\n }\n _getTimestampsForTable() {\n let timestamps = this._cache.all || [];\n if (timestamps.length) {\n return timestamps;\n }\n const data = this.getDataTimestamps();\n const label = this.getLabelTimestamps();\n if (data.length && label.length) {\n timestamps = this.normalize(data.concat(label));\n } else {\n timestamps = data.length ? data : label;\n }\n timestamps = this._cache.all = timestamps;\n return timestamps;\n }\n getDecimalForValue(value) {\n return (interpolate(this._table, value) - this._minPos) / this._tableRange;\n }\n getValueForPixel(pixel) {\n const offsets = this._offsets;\n const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end;\n return interpolate(this._table, decimal * this._tableRange + this._minPos, true);\n }\n}\nTimeSeriesScale.id = 'timeseries';\nTimeSeriesScale.defaults = TimeScale.defaults;\n\nvar scales = /*#__PURE__*/Object.freeze({\n__proto__: null,\nCategoryScale: CategoryScale,\nLinearScale: LinearScale,\nLogarithmicScale: LogarithmicScale,\nRadialLinearScale: RadialLinearScale,\nTimeScale: TimeScale,\nTimeSeriesScale: TimeSeriesScale\n});\n\nconst registerables = [\n controllers,\n elements,\n plugins,\n scales,\n];\n\nexport { Animation, Animations, ArcElement, BarController, BarElement, BasePlatform, BasicPlatform, BubbleController, CategoryScale, Chart, DatasetController, plugin_decimation as Decimation, DomPlatform, DoughnutController, Element, index as Filler, Interaction, plugin_legend as Legend, LineController, LineElement, LinearScale, LogarithmicScale, PieController, PointElement, PolarAreaController, RadarController, RadialLinearScale, Scale, ScatterController, plugin_subtitle as SubTitle, Ticks, TimeScale, TimeSeriesScale, plugin_title as Title, plugin_tooltip as Tooltip, adapters as _adapters, _detectPlatform, animator, controllers, elements, layouts, plugins, registerables, registry, scales };\n","import {Chart, registerables} from '../dist/chart.esm.js';\n\nChart.register(...registerables);\n\nexport default Chart;\n","/*!\n* chartjs-plugin-annotation v1.4.0\n* https://www.chartjs.org/chartjs-plugin-annotation/index\n * (c) 2022 chartjs-plugin-annotation Contributors\n * Released under the MIT License\n */\nimport { Element, defaults, Animations, Chart } from 'chart.js';\nimport { defined, distanceBetweenPoints, callback, isFinite, valueOrDefault, isObject, toRadians, toFont, isArray, addRoundedRectPath, toTRBLCorners, toPadding, PI, drawPoint, RAD_PER_DEG, clipArea, unclipArea } from 'chart.js/helpers';\n\nconst clickHooks = ['click', 'dblclick'];\nconst moveHooks = ['enter', 'leave'];\nconst hooks = clickHooks.concat(moveHooks);\n\nfunction updateListeners(chart, state, options) {\n state.listened = false;\n state.moveListened = false;\n\n hooks.forEach(hook => {\n if (typeof options[hook] === 'function') {\n state.listened = true;\n state.listeners[hook] = options[hook];\n } else if (defined(state.listeners[hook])) {\n delete state.listeners[hook];\n }\n });\n moveHooks.forEach(hook => {\n if (typeof options[hook] === 'function') {\n state.moveListened = true;\n }\n });\n\n if (!state.listened || !state.moveListened) {\n state.annotations.forEach(scope => {\n if (!state.listened) {\n clickHooks.forEach(hook => {\n if (typeof scope[hook] === 'function') {\n state.listened = true;\n }\n });\n }\n if (!state.moveListened) {\n moveHooks.forEach(hook => {\n if (typeof scope[hook] === 'function') {\n state.listened = true;\n state.moveListened = true;\n }\n });\n }\n });\n }\n}\n\nfunction handleEvent(state, event, options) {\n if (state.listened) {\n switch (event.type) {\n case 'mousemove':\n case 'mouseout':\n handleMoveEvents(state, event);\n break;\n case 'click':\n handleClickEvents(state, event, options);\n break;\n }\n }\n}\n\nfunction handleMoveEvents(state, event) {\n if (!state.moveListened) {\n return;\n }\n\n let element;\n\n if (event.type === 'mousemove') {\n element = getNearestItem(state.elements, event);\n }\n\n const previous = state.hovered;\n state.hovered = element;\n\n dispatchMoveEvents(state, {previous, element}, event);\n}\n\nfunction dispatchMoveEvents(state, elements, event) {\n const {previous, element} = elements;\n if (previous && previous !== element) {\n dispatchEvent(previous.options.leave || state.listeners.leave, previous, event);\n }\n if (element && element !== previous) {\n dispatchEvent(element.options.enter || state.listeners.enter, element, event);\n }\n}\n\nfunction handleClickEvents(state, event, options) {\n const listeners = state.listeners;\n const element = getNearestItem(state.elements, event);\n if (element) {\n const elOpts = element.options;\n const dblclick = elOpts.dblclick || listeners.dblclick;\n const click = elOpts.click || listeners.click;\n if (element.clickTimeout) {\n // 2nd click before timeout, so its a double click\n clearTimeout(element.clickTimeout);\n delete element.clickTimeout;\n dispatchEvent(dblclick, element, event);\n } else if (dblclick) {\n // if there is a dblclick handler, wait for dblClickSpeed ms before deciding its a click\n element.clickTimeout = setTimeout(() => {\n delete element.clickTimeout;\n dispatchEvent(click, element, event);\n }, options.dblClickSpeed);\n } else {\n // no double click handler, just call the click handler directly\n dispatchEvent(click, element, event);\n }\n }\n}\n\nfunction dispatchEvent(handler, element, event) {\n callback(handler, [element.$context, event]);\n}\n\nfunction getNearestItem(elements, position) {\n let minDistance = Number.POSITIVE_INFINITY;\n\n return elements\n .filter((element) => element.options.display && element.inRange(position.x, position.y))\n .reduce((nearestItems, element) => {\n const center = element.getCenterPoint();\n const distance = distanceBetweenPoints(position, center);\n\n if (distance < minDistance) {\n nearestItems = [element];\n minDistance = distance;\n } else if (distance === minDistance) {\n // Can have multiple items at the same distance in which case we sort by size\n nearestItems.push(element);\n }\n\n return nearestItems;\n }, [])\n .sort((a, b) => a._index - b._index)\n .slice(0, 1)[0]; // return only the top item\n}\n\nfunction adjustScaleRange(chart, scale, annotations) {\n const range = getScaleLimits(scale, annotations);\n let changed = changeScaleLimit(scale, range, 'min', 'suggestedMin');\n changed = changeScaleLimit(scale, range, 'max', 'suggestedMax') || changed;\n if (changed && typeof scale.handleTickRangeOptions === 'function') {\n scale.handleTickRangeOptions();\n }\n}\n\nfunction verifyScaleOptions(annotations, scales) {\n for (const annotation of annotations) {\n verifyScaleIDs(annotation, scales);\n }\n}\n\nfunction changeScaleLimit(scale, range, limit, suggestedLimit) {\n if (isFinite(range[limit]) && !scaleLimitDefined(scale.options, limit, suggestedLimit)) {\n const changed = scale[limit] !== range[limit];\n scale[limit] = range[limit];\n return changed;\n }\n}\n\nfunction scaleLimitDefined(scaleOptions, limit, suggestedLimit) {\n return defined(scaleOptions[limit]) || defined(scaleOptions[suggestedLimit]);\n}\n\nfunction verifyScaleIDs(annotation, scales) {\n for (const key of ['scaleID', 'xScaleID', 'yScaleID']) {\n if (annotation[key] && !scales[annotation[key]] && verifyProperties(annotation, key)) {\n console.warn(`No scale found with id '${annotation[key]}' for annotation '${annotation.id}'`);\n }\n }\n}\n\nfunction verifyProperties(annotation, key) {\n if (key === 'scaleID') {\n return true;\n }\n const axis = key.charAt(0);\n for (const prop of ['Min', 'Max', 'Value']) {\n if (defined(annotation[axis + prop])) {\n return true;\n }\n }\n return false;\n}\n\nfunction getScaleLimits(scale, annotations) {\n const axis = scale.axis;\n const scaleID = scale.id;\n const scaleIDOption = axis + 'ScaleID';\n const limits = {\n min: valueOrDefault(scale.min, Number.NEGATIVE_INFINITY),\n max: valueOrDefault(scale.max, Number.POSITIVE_INFINITY)\n };\n for (const annotation of annotations) {\n if (annotation.scaleID === scaleID) {\n updateLimits(annotation, scale, ['value', 'endValue'], limits);\n } else if (annotation[scaleIDOption] === scaleID) {\n updateLimits(annotation, scale, [axis + 'Min', axis + 'Max', axis + 'Value'], limits);\n }\n }\n return limits;\n}\n\nfunction updateLimits(annotation, scale, props, limits) {\n for (const prop of props) {\n const raw = annotation[prop];\n if (defined(raw)) {\n const value = scale.parse(raw);\n limits.min = Math.min(limits.min, value);\n limits.max = Math.max(limits.max, value);\n }\n }\n}\n\nconst EPSILON = 0.001;\n\nconst clamp = (x, from, to) => Math.min(to, Math.max(from, x));\n\nfunction clampAll(obj, from, to) {\n for (const key of Object.keys(obj)) {\n obj[key] = clamp(obj[key], from, to);\n }\n return obj;\n}\n\nfunction inPointRange(point, center, radius, borderWidth) {\n if (!point || !center || radius <= 0) {\n return false;\n }\n const hBorderWidth = borderWidth / 2 || 0;\n return (Math.pow(point.x - center.x, 2) + Math.pow(point.y - center.y, 2)) <= Math.pow(radius + hBorderWidth, 2);\n}\n\nfunction inBoxRange(mouseX, mouseY, {x, y, width, height}, borderWidth) {\n const hBorderWidth = borderWidth / 2;\n return mouseX >= x - hBorderWidth - EPSILON &&\n mouseX <= x + width + hBorderWidth + EPSILON &&\n mouseY >= y - hBorderWidth - EPSILON &&\n mouseY <= y + height + hBorderWidth + EPSILON;\n}\n\nfunction getElementCenterPoint(element, useFinalPosition) {\n const {x, y} = element.getProps(['x', 'y'], useFinalPosition);\n return {x, y};\n}\n\nconst isOlderPart = (act, req) => req > act || (act.length > req.length && act.substr(0, req.length) === req);\n\nfunction requireVersion(pkg, min, ver, strict = true) {\n const parts = ver.split('.');\n let i = 0;\n for (const req of min.split('.')) {\n const act = parts[i++];\n if (parseInt(req, 10) < parseInt(act, 10)) {\n break;\n }\n if (isOlderPart(act, req)) {\n if (strict) {\n throw new Error(`${pkg} v${ver} is not supported. v${min} or newer is required.`);\n } else {\n return false;\n }\n }\n }\n return true;\n}\n\nconst isPercentString = (s) => typeof s === 'string' && s.endsWith('%');\nconst toPercent = (s) => clamp(parseFloat(s) / 100, 0, 1);\n\nfunction getRelativePosition(size, positionOption) {\n if (positionOption === 'start') {\n return 0;\n }\n if (positionOption === 'end') {\n return size;\n }\n if (isPercentString(positionOption)) {\n return toPercent(positionOption) * size;\n }\n return size / 2;\n}\n\nfunction getSize(size, value) {\n if (typeof value === 'number') {\n return value;\n } else if (isPercentString(value)) {\n return toPercent(value) * size;\n }\n return size;\n}\n\nfunction calculateTextAlignment(size, options) {\n const {x, width} = size;\n const textAlign = options.textAlign;\n if (textAlign === 'center') {\n return x + width / 2;\n } else if (textAlign === 'end' || textAlign === 'right') {\n return x + width;\n }\n return x;\n}\n\nfunction toPosition(value) {\n if (isObject(value)) {\n return {\n x: valueOrDefault(value.x, 'center'),\n y: valueOrDefault(value.y, 'center'),\n };\n }\n value = valueOrDefault(value, 'center');\n return {\n x: value,\n y: value\n };\n}\n\nfunction isBoundToPoint(options) {\n return options && (defined(options.xValue) || defined(options.yValue));\n}\n\nconst widthCache = new Map();\n\n/**\n * Determine if content is an image or a canvas.\n * @param {*} content\n * @returns boolean|undefined\n * @todo move this function to chart.js helpers\n */\nfunction isImageOrCanvas(content) {\n if (content && typeof content === 'object') {\n const type = content.toString();\n return (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]');\n }\n}\n\n/**\n * Set the translation on the canvas if the rotation must be applied.\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {Element} element - annotation element to use for applying the translation\n * @param {number} rotation - rotation (in degrees) to apply\n */\nfunction translate(ctx, element, rotation) {\n if (rotation) {\n const center = element.getCenterPoint();\n ctx.translate(center.x, center.y);\n ctx.rotate(toRadians(rotation));\n ctx.translate(-center.x, -center.y);\n }\n}\n\n/**\n * Apply border options to the canvas context before drawing a shape\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {Object} options - options with border configuration\n * @returns {boolean} true is the border options have been applied\n */\nfunction setBorderStyle(ctx, options) {\n if (options && options.borderWidth) {\n ctx.lineCap = options.borderCapStyle;\n ctx.setLineDash(options.borderDash);\n ctx.lineDashOffset = options.borderDashOffset;\n ctx.lineJoin = options.borderJoinStyle;\n ctx.lineWidth = options.borderWidth;\n ctx.strokeStyle = options.borderColor;\n return true;\n }\n}\n\n/**\n * Apply shadow options to the canvas context before drawing a shape\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {Object} options - options with shadow configuration\n */\nfunction setShadowStyle(ctx, options) {\n ctx.shadowColor = options.backgroundShadowColor;\n ctx.shadowBlur = options.shadowBlur;\n ctx.shadowOffsetX = options.shadowOffsetX;\n ctx.shadowOffsetY = options.shadowOffsetY;\n}\n\n/**\n * Measure the label size using the label options.\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {Object} options - options to configure the label\n * @returns {{width: number, height: number}} the measured size of the label\n */\nfunction measureLabelSize(ctx, options) {\n const content = options.content;\n if (isImageOrCanvas(content)) {\n return {\n width: getSize(content.width, options.width),\n height: getSize(content.height, options.height)\n };\n }\n const font = toFont(options.font);\n const strokeWidth = options.textStrokeWidth;\n const lines = isArray(content) ? content : [content];\n const mapKey = lines.join() + font.string + strokeWidth + (ctx._measureText ? '-spriting' : '');\n if (!widthCache.has(mapKey)) {\n ctx.save();\n ctx.font = font.string;\n const count = lines.length;\n let width = 0;\n for (let i = 0; i < count; i++) {\n const text = lines[i];\n width = Math.max(width, ctx.measureText(text).width + strokeWidth);\n }\n ctx.restore();\n const height = count * font.lineHeight + strokeWidth;\n widthCache.set(mapKey, {width, height});\n }\n return widthCache.get(mapKey);\n}\n\n/**\n * Draw a box with the size and the styling options.\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {{x: number, y: number, width: number, height: number}} rect - rect to draw\n * @param {Object} options - options to style the box\n * @returns {undefined}\n */\nfunction drawBox(ctx, rect, options) {\n const {x, y, width, height} = rect;\n ctx.save();\n setShadowStyle(ctx, options);\n const stroke = setBorderStyle(ctx, options);\n ctx.fillStyle = options.backgroundColor;\n ctx.beginPath();\n addRoundedRectPath(ctx, {\n x, y, w: width, h: height,\n // TODO: v2 remove support for cornerRadius\n radius: clampAll(toTRBLCorners(valueOrDefault(options.cornerRadius, options.borderRadius)), 0, Math.min(width, height) / 2)\n });\n ctx.closePath();\n ctx.fill();\n if (stroke) {\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n }\n ctx.restore();\n}\n\n/**\n * Draw a label with the size and the styling options.\n * @param {CanvasRenderingContext2D} ctx - chart canvas context\n * @param {{x: number, y: number, width: number, height: number}} rect - rect to map teh label\n * @param {Object} options - options to style the label\n * @returns {undefined}\n */\nfunction drawLabel(ctx, rect, options) {\n const content = options.content;\n if (isImageOrCanvas(content)) {\n ctx.drawImage(content, rect.x, rect.y, rect.width, rect.height);\n return;\n }\n const labels = isArray(content) ? content : [content];\n const font = toFont(options.font);\n const lh = font.lineHeight;\n const x = calculateTextAlignment(rect, options);\n const y = rect.y + (lh / 2) + options.textStrokeWidth / 2;\n ctx.save();\n ctx.font = font.string;\n ctx.textBaseline = 'middle';\n ctx.textAlign = options.textAlign;\n if (setTextStrokeStyle(ctx, options)) {\n labels.forEach((l, i) => ctx.strokeText(l, x, y + (i * lh)));\n }\n ctx.fillStyle = options.color;\n labels.forEach((l, i) => ctx.fillText(l, x, y + (i * lh)));\n ctx.restore();\n}\n\nfunction setTextStrokeStyle(ctx, options) {\n if (options.textStrokeWidth > 0) {\n // https://stackoverflow.com/questions/13627111/drawing-text-with-an-outer-stroke-with-html5s-canvas\n ctx.lineJoin = 'round';\n ctx.miterLimit = 2;\n ctx.lineWidth = options.textStrokeWidth;\n ctx.strokeStyle = options.textStrokeColor;\n return true;\n }\n}\n\n/**\n * @typedef {import('chart.js').Point} Point\n */\n\n/**\n * @param {{x: number, y: number, width: number, height: number}} rect\n * @returns {Point}\n */\nfunction getRectCenterPoint(rect) {\n const {x, y, width, height} = rect;\n return {\n x: x + width / 2,\n y: y + height / 2\n };\n}\n\n/**\n * Rotate a `point` relative to `center` point by `angle`\n * @param {Point} point - the point to rotate\n * @param {Point} center - center point for rotation\n * @param {number} angle - angle for rotation, in radians\n * @returns {Point} rotated point\n */\nfunction rotated(point, center, angle) {\n const cos = Math.cos(angle);\n const sin = Math.sin(angle);\n const cx = center.x;\n const cy = center.y;\n\n return {\n x: cx + cos * (point.x - cx) - sin * (point.y - cy),\n y: cy + sin * (point.x - cx) + cos * (point.y - cy)\n };\n}\n\n/**\n * @typedef { import(\"chart.js\").Chart } Chart\n * @typedef { import(\"chart.js\").Scale } Scale\n * @typedef { import(\"chart.js\").Point } Point\n * @typedef { import('../../types/options').CoreAnnotationOptions } CoreAnnotationOptions\n * @typedef { import('../../types/options').PointAnnotationOptions } PointAnnotationOptions\n */\n\n/**\n * @param {Scale} scale\n * @param {number|string} value\n * @param {number} fallback\n * @returns {number}\n */\nfunction scaleValue(scale, value, fallback) {\n value = typeof value === 'number' ? value : scale.parse(value);\n return isFinite(value) ? scale.getPixelForValue(value) : fallback;\n}\n\n/**\n * @param {Scale} scale\n * @param {{start: number, end: number}} options\n * @returns {{start: number, end: number}}\n */\nfunction getChartDimensionByScale(scale, options) {\n if (scale) {\n const min = scaleValue(scale, options.min, options.start);\n const max = scaleValue(scale, options.max, options.end);\n return {\n start: Math.min(min, max),\n end: Math.max(min, max)\n };\n }\n return {\n start: options.start,\n end: options.end\n };\n}\n\n/**\n * @param {Chart} chart\n * @param {CoreAnnotationOptions} options\n * @returns {Point}\n */\nfunction getChartPoint(chart, options) {\n const {chartArea, scales} = chart;\n const xScale = scales[options.xScaleID];\n const yScale = scales[options.yScaleID];\n let x = chartArea.width / 2;\n let y = chartArea.height / 2;\n\n if (xScale) {\n x = scaleValue(xScale, options.xValue, x);\n }\n\n if (yScale) {\n y = scaleValue(yScale, options.yValue, y);\n }\n return {x, y};\n}\n\n/**\n * @param {Chart} chart\n * @param {CoreAnnotationOptions} options\n * @returns {{x?:number, y?: number, x2?: number, y2?: number, width?: number, height?: number}}\n */\nfunction getChartRect(chart, options) {\n const xScale = chart.scales[options.xScaleID];\n const yScale = chart.scales[options.yScaleID];\n let {top: y, left: x, bottom: y2, right: x2} = chart.chartArea;\n\n if (!xScale && !yScale) {\n return {};\n }\n\n const xDim = getChartDimensionByScale(xScale, {min: options.xMin, max: options.xMax, start: x, end: x2});\n x = xDim.start;\n x2 = xDim.end;\n const yDim = getChartDimensionByScale(yScale, {min: options.yMin, max: options.yMax, start: y, end: y2});\n y = yDim.start;\n y2 = yDim.end;\n\n return {\n x,\n y,\n x2,\n y2,\n width: x2 - x,\n height: y2 - y\n };\n}\n\n/**\n * @param {Chart} chart\n * @param {PointAnnotationOptions} options\n */\nfunction getChartCircle(chart, options) {\n const point = getChartPoint(chart, options);\n return {\n x: point.x + options.xAdjust,\n y: point.y + options.yAdjust,\n width: options.radius * 2,\n height: options.radius * 2\n };\n}\n\n/**\n * @param {Chart} chart\n * @param {PointAnnotationOptions} options\n * @returns\n */\nfunction resolvePointPosition(chart, options) {\n if (!isBoundToPoint(options)) {\n const box = getChartRect(chart, options);\n const point = getRectCenterPoint(box);\n let radius = options.radius;\n if (!radius || isNaN(radius)) {\n radius = Math.min(box.width, box.height) / 2;\n options.radius = radius;\n }\n return {\n x: point.x + options.xAdjust,\n y: point.y + options.yAdjust,\n width: radius * 2,\n height: radius * 2\n };\n }\n return getChartCircle(chart, options);\n}\n\nclass BoxAnnotation extends Element {\n inRange(mouseX, mouseY, useFinalPosition) {\n const {x, y} = rotated({x: mouseX, y: mouseY}, this.getCenterPoint(useFinalPosition), toRadians(-this.options.rotation));\n return inBoxRange(x, y, this.getProps(['x', 'y', 'width', 'height'], useFinalPosition), this.options.borderWidth);\n }\n\n getCenterPoint(useFinalPosition) {\n return getRectCenterPoint(this.getProps(['x', 'y', 'width', 'height'], useFinalPosition));\n }\n\n draw(ctx) {\n ctx.save();\n translate(ctx, this, this.options.rotation);\n drawBox(ctx, this, this.options);\n ctx.restore();\n }\n\n drawLabel(ctx) {\n const {x, y, width, height, options} = this;\n const {label, borderWidth} = options;\n const halfBorder = borderWidth / 2;\n const position = toPosition(label.position);\n const padding = toPadding(label.padding);\n const labelSize = measureLabelSize(ctx, label);\n const labelRect = {\n x: calculateX(this, labelSize, position, padding),\n y: calculateY(this, labelSize, position, padding),\n width: labelSize.width,\n height: labelSize.height\n };\n\n ctx.save();\n translate(ctx, this, label.rotation);\n ctx.beginPath();\n ctx.rect(x + halfBorder + padding.left, y + halfBorder + padding.top,\n width - borderWidth - padding.width, height - borderWidth - padding.height);\n ctx.clip();\n drawLabel(ctx, labelRect, label);\n ctx.restore();\n }\n\n resolveElementProperties(chart, options) {\n return getChartRect(chart, options);\n }\n}\n\nBoxAnnotation.id = 'boxAnnotation';\n\nBoxAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundShadowColor: 'transparent',\n borderCapStyle: 'butt',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderRadius: 0,\n borderShadowColor: 'transparent',\n borderWidth: 1,\n cornerRadius: undefined, // TODO: v2 remove support for cornerRadius\n display: true,\n label: {\n borderWidth: undefined,\n color: 'black',\n content: null,\n drawTime: undefined,\n enabled: false,\n font: {\n family: undefined,\n lineHeight: undefined,\n size: undefined,\n style: undefined,\n weight: 'bold'\n },\n height: undefined,\n padding: 6,\n position: 'center',\n rotation: undefined,\n textAlign: 'start',\n textStrokeColor: undefined,\n textStrokeWidth: 0,\n xAdjust: 0,\n yAdjust: 0,\n width: undefined\n },\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y'\n};\n\nBoxAnnotation.defaultRoutes = {\n borderColor: 'color',\n backgroundColor: 'color'\n};\n\nBoxAnnotation.descriptors = {\n label: {\n _fallback: true\n }\n};\n\nfunction calculateX(box, labelSize, position, padding) {\n const {x: start, x2: end, width: size, options} = box;\n const {xAdjust: adjust, borderWidth} = options.label;\n return calculatePosition$1({start, end, size}, {\n position: position.x,\n padding: {start: padding.left, end: padding.right},\n adjust, borderWidth,\n size: labelSize.width\n });\n}\n\nfunction calculateY(box, labelSize, position, padding) {\n const {y: start, y2: end, height: size, options} = box;\n const {yAdjust: adjust, borderWidth} = options.label;\n return calculatePosition$1({start, end, size}, {\n position: position.y,\n padding: {start: padding.top, end: padding.bottom},\n adjust, borderWidth,\n size: labelSize.height\n });\n}\n\nfunction calculatePosition$1(boxOpts, labelOpts) {\n const {start, end} = boxOpts;\n const {position, padding: {start: padStart, end: padEnd}, adjust, borderWidth} = labelOpts;\n const availableSize = end - borderWidth - start - padStart - padEnd - labelOpts.size;\n return start + borderWidth / 2 + adjust + padStart + getRelativePosition(availableSize, position);\n}\n\nconst pointInLine = (p1, p2, t) => ({x: p1.x + t * (p2.x - p1.x), y: p1.y + t * (p2.y - p1.y)});\nconst interpolateX = (y, p1, p2) => pointInLine(p1, p2, Math.abs((y - p1.y) / (p2.y - p1.y))).x;\nconst interpolateY = (x, p1, p2) => pointInLine(p1, p2, Math.abs((x - p1.x) / (p2.x - p1.x))).y;\nconst sqr = v => v * v;\nconst defaultEpsilon = 0.001;\n\nfunction isLineInArea({x, y, x2, y2}, {top, right, bottom, left}) {\n return !(\n (x < left && x2 < left) ||\n (x > right && x2 > right) ||\n (y < top && y2 < top) ||\n (y > bottom && y2 > bottom)\n );\n}\n\nfunction limitPointToArea({x, y}, p2, {top, right, bottom, left}) {\n if (x < left) {\n y = interpolateY(left, {x, y}, p2);\n x = left;\n }\n if (x > right) {\n y = interpolateY(right, {x, y}, p2);\n x = right;\n }\n if (y < top) {\n x = interpolateX(top, {x, y}, p2);\n y = top;\n }\n if (y > bottom) {\n x = interpolateX(bottom, {x, y}, p2);\n y = bottom;\n }\n return {x, y};\n}\n\nfunction limitLineToArea(p1, p2, area) {\n const {x, y} = limitPointToArea(p1, p2, area);\n const {x: x2, y: y2} = limitPointToArea(p2, p1, area);\n return {x, y, x2, y2, width: Math.abs(x2 - x), height: Math.abs(y2 - y)};\n}\n\nclass LineAnnotation extends Element {\n\n // TODO: make private in v2\n intersects(x, y, epsilon = defaultEpsilon, useFinalPosition) {\n // Adapted from https://stackoverflow.com/a/6853926/25507\n const {x: x1, y: y1, x2, y2} = this.getProps(['x', 'y', 'x2', 'y2'], useFinalPosition);\n const dx = x2 - x1;\n const dy = y2 - y1;\n const lenSq = sqr(dx) + sqr(dy);\n const t = lenSq === 0 ? -1 : ((x - x1) * dx + (y - y1) * dy) / lenSq;\n let xx, yy;\n if (t < 0) {\n xx = x1;\n yy = y1;\n } else if (t > 1) {\n xx = x2;\n yy = y2;\n } else {\n xx = x1 + t * dx;\n yy = y1 + t * dy;\n }\n return (sqr(x - xx) + sqr(y - yy)) <= epsilon;\n }\n\n /**\n * @todo make private in v2\n * @param {boolean} useFinalPosition - use the element's animation target instead of current position\n * @param {top, right, bottom, left} [chartArea] - optional, area of the chart\n * @returns {boolean} true if the label is visible\n */\n labelIsVisible(useFinalPosition, chartArea) {\n const labelOpts = this.options.label;\n if (!labelOpts || !labelOpts.enabled) {\n return false;\n }\n return !chartArea || isLineInArea(this.getProps(['x', 'y', 'x2', 'y2'], useFinalPosition), chartArea);\n }\n\n // TODO: make private in v2\n isOnLabel(mouseX, mouseY, useFinalPosition) {\n if (!this.labelIsVisible(useFinalPosition)) {\n return false;\n }\n const {labelX, labelY, labelWidth, labelHeight, labelRotation} = this.getProps(['labelX', 'labelY', 'labelWidth', 'labelHeight', 'labelRotation'], useFinalPosition);\n const {x, y} = rotated({x: mouseX, y: mouseY}, {x: labelX, y: labelY}, -labelRotation);\n const hBorderWidth = this.options.label.borderWidth / 2 || 0;\n const w2 = labelWidth / 2 + hBorderWidth;\n const h2 = labelHeight / 2 + hBorderWidth;\n return x >= labelX - w2 - defaultEpsilon && x <= labelX + w2 + defaultEpsilon &&\n y >= labelY - h2 - defaultEpsilon && y <= labelY + h2 + defaultEpsilon;\n }\n\n inRange(mouseX, mouseY, useFinalPosition) {\n const epsilon = sqr(this.options.borderWidth / 2);\n return this.intersects(mouseX, mouseY, epsilon, useFinalPosition) || this.isOnLabel(mouseX, mouseY, useFinalPosition);\n }\n\n getCenterPoint() {\n return {\n x: (this.x2 + this.x) / 2,\n y: (this.y2 + this.y) / 2\n };\n }\n\n draw(ctx) {\n const {x, y, x2, y2, options} = this;\n\n ctx.save();\n if (!setBorderStyle(ctx, options)) {\n // no border width, then line is not drawn\n return ctx.restore();\n }\n setShadowStyle(ctx, options);\n const angle = Math.atan2(y2 - y, x2 - x);\n const length = Math.sqrt(Math.pow(x2 - x, 2) + Math.pow(y2 - y, 2));\n const {startOpts, endOpts, startAdjust, endAdjust} = getArrowHeads(this);\n\n ctx.translate(x, y);\n ctx.rotate(angle);\n ctx.beginPath();\n ctx.moveTo(0 + startAdjust, 0);\n ctx.lineTo(length - endAdjust, 0);\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n drawArrowHead(ctx, 0, startAdjust, startOpts);\n drawArrowHead(ctx, length, -endAdjust, endOpts);\n ctx.restore();\n }\n\n drawLabel(ctx, chartArea) {\n if (!this.labelIsVisible(false, chartArea)) {\n return;\n }\n const {labelX, labelY, labelWidth, labelHeight, labelRotation, labelPadding, labelTextSize, options: {label}} = this;\n\n ctx.save();\n ctx.translate(labelX, labelY);\n ctx.rotate(labelRotation);\n\n const boxRect = {\n x: -(labelWidth / 2),\n y: -(labelHeight / 2),\n width: labelWidth,\n height: labelHeight\n };\n drawBox(ctx, boxRect, label);\n\n const labelTextRect = {\n x: -(labelWidth / 2) + labelPadding.left + label.borderWidth / 2,\n y: -(labelHeight / 2) + labelPadding.top + label.borderWidth / 2,\n width: labelTextSize.width,\n height: labelTextSize.height\n };\n drawLabel(ctx, labelTextRect, label);\n ctx.restore();\n }\n\n resolveElementProperties(chart, options) {\n const scale = chart.scales[options.scaleID];\n let {top: y, left: x, bottom: y2, right: x2} = chart.chartArea;\n let min, max;\n\n if (scale) {\n min = scaleValue(scale, options.value, NaN);\n max = scaleValue(scale, options.endValue, min);\n if (scale.isHorizontal()) {\n x = min;\n x2 = max;\n } else {\n y = min;\n y2 = max;\n }\n } else {\n const xScale = chart.scales[options.xScaleID];\n const yScale = chart.scales[options.yScaleID];\n\n if (xScale) {\n x = scaleValue(xScale, options.xMin, x);\n x2 = scaleValue(xScale, options.xMax, x2);\n }\n\n if (yScale) {\n y = scaleValue(yScale, options.yMin, y);\n y2 = scaleValue(yScale, options.yMax, y2);\n }\n }\n const inside = isLineInArea({x, y, x2, y2}, chart.chartArea);\n const properties = inside\n ? limitLineToArea({x, y}, {x: x2, y: y2}, chart.chartArea)\n : {x, y, x2, y2, width: Math.abs(x2 - x), height: Math.abs(y2 - y)};\n\n const label = options.label;\n if (label && label.content) {\n return loadLabelRect(properties, chart, label);\n }\n return properties;\n }\n}\n\nLineAnnotation.id = 'lineAnnotation';\n\nconst arrowHeadsDefaults = {\n backgroundColor: undefined,\n backgroundShadowColor: undefined,\n borderColor: undefined,\n borderDash: undefined,\n borderDashOffset: undefined,\n borderShadowColor: undefined,\n borderWidth: undefined,\n enabled: undefined,\n fill: undefined,\n length: undefined,\n shadowBlur: undefined,\n shadowOffsetX: undefined,\n shadowOffsetY: undefined,\n width: undefined\n};\n\nLineAnnotation.defaults = {\n adjustScaleRange: true,\n arrowHeads: {\n enabled: false,\n end: Object.assign({}, arrowHeadsDefaults),\n fill: false,\n length: 12,\n start: Object.assign({}, arrowHeadsDefaults),\n width: 6\n },\n borderDash: [],\n borderDashOffset: 0,\n borderShadowColor: 'transparent',\n borderWidth: 2,\n display: true,\n endValue: undefined,\n label: {\n backgroundColor: 'rgba(0,0,0,0.8)',\n backgroundShadowColor: 'transparent',\n borderCapStyle: 'butt',\n borderColor: 'black',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderRadius: 6,\n borderShadowColor: 'transparent',\n borderWidth: 0,\n color: '#fff',\n content: null,\n cornerRadius: undefined, // TODO: v2 remove support for cornerRadius\n drawTime: undefined,\n enabled: false,\n font: {\n family: undefined,\n lineHeight: undefined,\n size: undefined,\n style: undefined,\n weight: 'bold'\n },\n height: undefined,\n padding: 6,\n position: 'center',\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n textAlign: 'center',\n textStrokeColor: undefined,\n textStrokeWidth: 0,\n width: undefined,\n xAdjust: 0,\n xPadding: undefined, // TODO: v2 remove support for xPadding\n yAdjust: 0,\n yPadding: undefined, // TODO: v2 remove support for yPadding\n },\n scaleID: undefined,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n value: undefined,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y'\n};\n\nLineAnnotation.descriptors = {\n arrowHeads: {\n start: {\n _fallback: true\n },\n end: {\n _fallback: true\n },\n _fallback: true\n }\n};\n\nLineAnnotation.defaultRoutes = {\n borderColor: 'color'\n};\n\nfunction loadLabelRect(line, chart, options) {\n // TODO: v2 remove support for xPadding and yPadding\n const {padding: lblPadding, xPadding, yPadding, borderWidth} = options;\n const padding = getPadding(lblPadding, xPadding, yPadding);\n const textSize = measureLabelSize(chart.ctx, options);\n const width = textSize.width + padding.width + borderWidth;\n const height = textSize.height + padding.height + borderWidth;\n const labelRect = calculateLabelPosition(line, options, {width, height, padding}, chart.chartArea);\n line.labelX = labelRect.x;\n line.labelY = labelRect.y;\n line.labelWidth = labelRect.width;\n line.labelHeight = labelRect.height;\n line.labelRotation = labelRect.rotation;\n line.labelPadding = padding;\n line.labelTextSize = textSize;\n return line;\n}\n\nfunction calculateAutoRotation(line) {\n const {x, y, x2, y2} = line;\n const rotation = Math.atan2(y2 - y, x2 - x);\n // Flip the rotation if it goes > PI/2 or < -PI/2, so label stays upright\n return rotation > PI / 2 ? rotation - PI : rotation < PI / -2 ? rotation + PI : rotation;\n}\n\n// TODO: v2 remove support for xPadding and yPadding\nfunction getPadding(padding, xPadding, yPadding) {\n let tempPadding = padding;\n if (xPadding || yPadding) {\n tempPadding = {x: xPadding || 6, y: yPadding || 6};\n }\n return toPadding(tempPadding);\n}\n\nfunction calculateLabelPosition(line, label, sizes, chartArea) {\n const {width, height, padding} = sizes;\n const {xAdjust, yAdjust} = label;\n const p1 = {x: line.x, y: line.y};\n const p2 = {x: line.x2, y: line.y2};\n const rotation = label.rotation === 'auto' ? calculateAutoRotation(line) : toRadians(label.rotation);\n const size = rotatedSize(width, height, rotation);\n const t = calculateT(line, label, {labelSize: size, padding}, chartArea);\n const pt = pointInLine(p1, p2, t);\n const xCoordinateSizes = {size: size.w, min: chartArea.left, max: chartArea.right, padding: padding.left};\n const yCoordinateSizes = {size: size.h, min: chartArea.top, max: chartArea.bottom, padding: padding.top};\n\n return {\n x: adjustLabelCoordinate(pt.x, xCoordinateSizes) + xAdjust,\n y: adjustLabelCoordinate(pt.y, yCoordinateSizes) + yAdjust,\n width,\n height,\n rotation\n };\n}\n\nfunction rotatedSize(width, height, rotation) {\n const cos = Math.cos(rotation);\n const sin = Math.sin(rotation);\n return {\n w: Math.abs(width * cos) + Math.abs(height * sin),\n h: Math.abs(width * sin) + Math.abs(height * cos)\n };\n}\n\nfunction calculateT(line, label, sizes, chartArea) {\n let t;\n const space = spaceAround(line, chartArea);\n if (label.position === 'start') {\n t = calculateTAdjust({w: line.x2 - line.x, h: line.y2 - line.y}, sizes, label, space);\n } else if (label.position === 'end') {\n t = 1 - calculateTAdjust({w: line.x - line.x2, h: line.y - line.y2}, sizes, label, space);\n } else {\n t = getRelativePosition(1, label.position);\n }\n return t;\n}\n\nfunction calculateTAdjust(lineSize, sizes, label, space) {\n const {labelSize, padding} = sizes;\n const lineW = lineSize.w * space.dx;\n const lineH = lineSize.h * space.dy;\n const x = (lineW > 0) && ((labelSize.w / 2 + padding.left - space.x) / lineW);\n const y = (lineH > 0) && ((labelSize.h / 2 + padding.top - space.y) / lineH);\n return clamp(Math.max(x, y), 0, 0.25);\n}\n\nfunction spaceAround(line, chartArea) {\n const {x, x2, y, y2} = line;\n const t = Math.min(y, y2) - chartArea.top;\n const l = Math.min(x, x2) - chartArea.left;\n const b = chartArea.bottom - Math.max(y, y2);\n const r = chartArea.right - Math.max(x, x2);\n return {\n x: Math.min(l, r),\n y: Math.min(t, b),\n dx: l <= r ? 1 : -1,\n dy: t <= b ? 1 : -1\n };\n}\n\nfunction adjustLabelCoordinate(coordinate, labelSizes) {\n const {size, min, max, padding} = labelSizes;\n const halfSize = size / 2;\n if (size > max - min) {\n // if it does not fit, display as much as possible\n return (max + min) / 2;\n }\n if (min >= (coordinate - padding - halfSize)) {\n coordinate = min + padding + halfSize;\n }\n if (max <= (coordinate + padding + halfSize)) {\n coordinate = max - padding - halfSize;\n }\n return coordinate;\n}\n\nfunction getArrowHeads(line) {\n const options = line.options;\n const arrowStartOpts = options.arrowHeads && options.arrowHeads.start;\n const arrowEndOpts = options.arrowHeads && options.arrowHeads.end;\n return {\n startOpts: arrowStartOpts,\n endOpts: arrowEndOpts,\n startAdjust: getLineAdjust(line, arrowStartOpts),\n endAdjust: getLineAdjust(line, arrowEndOpts)\n };\n}\n\nfunction getLineAdjust(line, arrowOpts) {\n if (!arrowOpts || !arrowOpts.enabled) {\n return 0;\n }\n const {length, width} = arrowOpts;\n const adjust = line.options.borderWidth / 2;\n const p1 = {x: length, y: width + adjust};\n const p2 = {x: 0, y: adjust};\n return Math.abs(interpolateX(0, p1, p2));\n}\n\nfunction drawArrowHead(ctx, offset, adjust, arrowOpts) {\n if (!arrowOpts || !arrowOpts.enabled) {\n return;\n }\n const {length, width, fill, backgroundColor, borderColor} = arrowOpts;\n const arrowOffsetX = Math.abs(offset - length) + adjust;\n ctx.beginPath();\n setShadowStyle(ctx, arrowOpts);\n setBorderStyle(ctx, arrowOpts);\n ctx.moveTo(arrowOffsetX, -width);\n ctx.lineTo(offset + adjust, 0);\n ctx.lineTo(arrowOffsetX, width);\n if (fill === true) {\n ctx.fillStyle = backgroundColor || borderColor;\n ctx.closePath();\n ctx.fill();\n ctx.shadowColor = 'transparent';\n } else {\n ctx.shadowColor = arrowOpts.borderShadowColor;\n }\n ctx.stroke();\n}\n\nclass EllipseAnnotation extends Element {\n\n inRange(mouseX, mouseY, useFinalPosition) {\n return pointInEllipse({x: mouseX, y: mouseY}, this.getProps(['width', 'height'], useFinalPosition), this.options.rotation, this.options.borderWidth);\n }\n\n getCenterPoint(useFinalPosition) {\n return getRectCenterPoint(this.getProps(['x', 'y', 'width', 'height'], useFinalPosition));\n }\n\n draw(ctx) {\n const {width, height, options} = this;\n const center = this.getCenterPoint();\n\n ctx.save();\n translate(ctx, this, options.rotation);\n setShadowStyle(ctx, this.options);\n ctx.beginPath();\n ctx.fillStyle = options.backgroundColor;\n const stroke = setBorderStyle(ctx, options);\n ctx.ellipse(center.x, center.y, height / 2, width / 2, PI / 2, 0, 2 * PI);\n ctx.fill();\n if (stroke) {\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n }\n ctx.restore();\n }\n\n resolveElementProperties(chart, options) {\n return getChartRect(chart, options);\n }\n\n}\n\nEllipseAnnotation.id = 'ellipseAnnotation';\n\nEllipseAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundShadowColor: 'transparent',\n borderDash: [],\n borderDashOffset: 0,\n borderShadowColor: 'transparent',\n borderWidth: 1,\n display: true,\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y'\n};\n\nEllipseAnnotation.defaultRoutes = {\n borderColor: 'color',\n backgroundColor: 'color'\n};\n\nfunction pointInEllipse(p, ellipse, rotation, borderWidth) {\n const {width, height} = ellipse;\n const center = ellipse.getCenterPoint(true);\n const xRadius = width / 2;\n const yRadius = height / 2;\n\n if (xRadius <= 0 || yRadius <= 0) {\n return false;\n }\n // https://stackoverflow.com/questions/7946187/point-and-ellipse-rotated-position-test-algorithm\n const angle = toRadians(rotation || 0);\n const hBorderWidth = borderWidth / 2 || 0;\n const cosAngle = Math.cos(angle);\n const sinAngle = Math.sin(angle);\n const a = Math.pow(cosAngle * (p.x - center.x) + sinAngle * (p.y - center.y), 2);\n const b = Math.pow(sinAngle * (p.x - center.x) - cosAngle * (p.y - center.y), 2);\n return (a / Math.pow(xRadius + hBorderWidth, 2)) + (b / Math.pow(yRadius + hBorderWidth, 2)) <= 1.0001;\n}\n\nclass LabelAnnotation extends Element {\n\n inRange(mouseX, mouseY, useFinalPosition) {\n const {x, y} = rotated({x: mouseX, y: mouseY}, this.getCenterPoint(useFinalPosition), toRadians(-this.options.rotation));\n return inBoxRange(x, y, this.getProps(['x', 'y', 'width', 'height'], useFinalPosition), this.options.borderWidth);\n }\n\n getCenterPoint(useFinalPosition) {\n return getRectCenterPoint(this.getProps(['x', 'y', 'width', 'height'], useFinalPosition));\n }\n\n draw(ctx) {\n if (!this.options.content) {\n return;\n }\n const {labelX, labelY, labelWidth, labelHeight, options} = this;\n ctx.save();\n translate(ctx, this, options.rotation);\n drawCallout(ctx, this);\n drawBox(ctx, this, options);\n drawLabel(ctx, {x: labelX, y: labelY, width: labelWidth, height: labelHeight}, options);\n ctx.restore();\n }\n\n // TODO: make private in v2\n resolveElementProperties(chart, options) {\n const point = !isBoundToPoint(options) ? getRectCenterPoint(getChartRect(chart, options)) : getChartPoint(chart, options);\n const padding = toPadding(options.padding);\n const labelSize = measureLabelSize(chart.ctx, options);\n const boxSize = measureRect(point, labelSize, options, padding);\n const hBorderWidth = options.borderWidth / 2;\n const properties = {\n pointX: point.x,\n pointY: point.y,\n ...boxSize,\n labelX: boxSize.x + padding.left + hBorderWidth,\n labelY: boxSize.y + padding.top + hBorderWidth,\n labelWidth: labelSize.width,\n labelHeight: labelSize.height\n };\n properties.calloutPosition = options.callout.enabled && resolveCalloutPosition(properties, options.callout, options.rotation);\n return properties;\n }\n}\n\nLabelAnnotation.id = 'labelAnnotation';\n\nLabelAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundColor: 'transparent',\n backgroundShadowColor: 'transparent',\n borderCapStyle: 'butt',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderRadius: 0,\n borderShadowColor: 'transparent',\n borderWidth: 0,\n callout: {\n borderCapStyle: 'butt',\n borderColor: undefined,\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderWidth: 1,\n enabled: false,\n margin: 5,\n position: 'auto',\n side: 5,\n start: '50%',\n },\n color: 'black',\n content: null,\n display: true,\n font: {\n family: undefined,\n lineHeight: undefined,\n size: undefined,\n style: undefined,\n weight: undefined\n },\n height: undefined,\n padding: 6,\n position: 'center',\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n textAlign: 'center',\n textStrokeColor: undefined,\n textStrokeWidth: 0,\n width: undefined,\n xAdjust: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n xValue: undefined,\n yAdjust: 0,\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y',\n yValue: undefined\n};\n\nLabelAnnotation.defaultRoutes = {\n borderColor: 'color'\n};\n\nfunction measureRect(point, size, options, padding) {\n const width = size.width + padding.width + options.borderWidth;\n const height = size.height + padding.height + options.borderWidth;\n const position = toPosition(options.position);\n\n return {\n x: calculatePosition(point.x, width, options.xAdjust, position.x),\n y: calculatePosition(point.y, height, options.yAdjust, position.y),\n width,\n height\n };\n}\n\nfunction calculatePosition(start, size, adjust = 0, position) {\n return start - getRelativePosition(size, position) + adjust;\n}\n\nfunction drawCallout(ctx, element) {\n const {pointX, pointY, calloutPosition, options} = element;\n if (!calloutPosition || element.inRange(pointX, pointY)) {\n return;\n }\n const callout = options.callout;\n\n ctx.save();\n ctx.beginPath();\n const stroke = setBorderStyle(ctx, callout);\n if (!stroke) {\n return ctx.restore();\n }\n const {separatorStart, separatorEnd} = getCalloutSeparatorCoord(element, calloutPosition);\n const {sideStart, sideEnd} = getCalloutSideCoord(element, calloutPosition, separatorStart);\n if (callout.margin > 0 || options.borderWidth === 0) {\n ctx.moveTo(separatorStart.x, separatorStart.y);\n ctx.lineTo(separatorEnd.x, separatorEnd.y);\n }\n ctx.moveTo(sideStart.x, sideStart.y);\n ctx.lineTo(sideEnd.x, sideEnd.y);\n const rotatedPoint = rotated({x: pointX, y: pointY}, element.getCenterPoint(), toRadians(-options.rotation));\n ctx.lineTo(rotatedPoint.x, rotatedPoint.y);\n ctx.stroke();\n ctx.restore();\n}\n\nfunction getCalloutSeparatorCoord(element, position) {\n const {x, y, width, height} = element;\n const adjust = getCalloutSeparatorAdjust(element, position);\n let separatorStart, separatorEnd;\n if (position === 'left' || position === 'right') {\n separatorStart = {x: x + adjust, y};\n separatorEnd = {x: separatorStart.x, y: separatorStart.y + height};\n } else {\n // position 'top' or 'bottom'\n separatorStart = {x, y: y + adjust};\n separatorEnd = {x: separatorStart.x + width, y: separatorStart.y};\n }\n return {separatorStart, separatorEnd};\n}\n\nfunction getCalloutSeparatorAdjust(element, position) {\n const {width, height, options} = element;\n const adjust = options.callout.margin + options.borderWidth / 2;\n if (position === 'right') {\n return width + adjust;\n } else if (position === 'bottom') {\n return height + adjust;\n }\n return -adjust;\n}\n\nfunction getCalloutSideCoord(element, position, separatorStart) {\n const {y, width, height, options} = element;\n const start = options.callout.start;\n const side = getCalloutSideAdjust(position, options.callout);\n let sideStart, sideEnd;\n if (position === 'left' || position === 'right') {\n sideStart = {x: separatorStart.x, y: y + getSize(height, start)};\n sideEnd = {x: sideStart.x + side, y: sideStart.y};\n } else {\n // position 'top' or 'bottom'\n sideStart = {x: separatorStart.x + getSize(width, start), y: separatorStart.y};\n sideEnd = {x: sideStart.x, y: sideStart.y + side};\n }\n return {sideStart, sideEnd};\n}\n\nfunction getCalloutSideAdjust(position, options) {\n const side = options.side;\n if (position === 'left' || position === 'top') {\n return -side;\n }\n return side;\n}\n\nfunction resolveCalloutPosition(properties, options, rotation) {\n const position = options.position;\n if (position === 'left' || position === 'right' || position === 'top' || position === 'bottom') {\n return position;\n }\n return resolveCalloutAutoPosition(properties, options, rotation);\n}\n\nconst positions = ['left', 'bottom', 'top', 'right'];\n\nfunction resolveCalloutAutoPosition(properties, options, rotation) {\n const {x, y, width, height, pointX, pointY} = properties;\n const center = {x: x + width / 2, y: y + height / 2};\n const start = options.start;\n const xAdjust = getSize(width, start);\n const yAdjust = getSize(height, start);\n const xPoints = [x, x + xAdjust, x + xAdjust, x + width];\n const yPoints = [y + yAdjust, y + height, y, y + yAdjust];\n const result = [];\n for (let index = 0; index < 4; index++) {\n const rotatedPoint = rotated({x: xPoints[index], y: yPoints[index]}, center, toRadians(rotation));\n result.push({\n position: positions[index],\n distance: distanceBetweenPoints(rotatedPoint, {x: pointX, y: pointY})\n });\n }\n return result.sort((a, b) => a.distance - b.distance)[0].position;\n}\n\nclass PointAnnotation extends Element {\n\n inRange(mouseX, mouseY, useFinalPosition) {\n const {width} = this.getProps(['width'], useFinalPosition);\n return inPointRange({x: mouseX, y: mouseY}, this.getCenterPoint(useFinalPosition), width / 2, this.options.borderWidth);\n }\n\n getCenterPoint(useFinalPosition) {\n return getElementCenterPoint(this, useFinalPosition);\n }\n\n draw(ctx) {\n const options = this.options;\n const borderWidth = options.borderWidth;\n if (options.radius < 0.1) {\n return;\n }\n ctx.save();\n ctx.fillStyle = options.backgroundColor;\n setShadowStyle(ctx, options);\n const stroke = setBorderStyle(ctx, options);\n options.borderWidth = 0;\n drawPoint(ctx, options, this.x, this.y);\n if (stroke && !isImageOrCanvas(options.pointStyle)) {\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n }\n ctx.restore();\n options.borderWidth = borderWidth;\n }\n\n resolveElementProperties(chart, options) {\n return resolvePointPosition(chart, options);\n }\n}\n\nPointAnnotation.id = 'pointAnnotation';\n\nPointAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundShadowColor: 'transparent',\n borderDash: [],\n borderDashOffset: 0,\n borderShadowColor: 'transparent',\n borderWidth: 1,\n display: true,\n pointStyle: 'circle',\n radius: 10,\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n xAdjust: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n xValue: undefined,\n yAdjust: 0,\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y',\n yValue: undefined\n};\n\nPointAnnotation.defaultRoutes = {\n borderColor: 'color',\n backgroundColor: 'color'\n};\n\nclass PolygonAnnotation extends Element {\n inRange(mouseX, mouseY, useFinalPosition) {\n return this.options.radius >= 0.1 && this.elements.length > 1 && pointIsInPolygon(this.elements, mouseX, mouseY, useFinalPosition);\n }\n\n getCenterPoint(useFinalPosition) {\n return getElementCenterPoint(this, useFinalPosition);\n }\n\n draw(ctx) {\n const {elements, options} = this;\n ctx.save();\n ctx.beginPath();\n ctx.fillStyle = options.backgroundColor;\n setShadowStyle(ctx, options);\n const stroke = setBorderStyle(ctx, options);\n let first = true;\n for (const el of elements) {\n if (first) {\n ctx.moveTo(el.x, el.y);\n first = false;\n } else {\n ctx.lineTo(el.x, el.y);\n }\n }\n ctx.closePath();\n ctx.fill();\n // If no border, don't draw it\n if (stroke) {\n ctx.shadowColor = options.borderShadowColor;\n ctx.stroke();\n }\n ctx.restore();\n }\n\n resolveElementProperties(chart, options) {\n const {x, y, width, height} = resolvePointPosition(chart, options);\n const {sides, radius, rotation, borderWidth} = options;\n const halfBorder = borderWidth / 2;\n const elements = [];\n const angle = (2 * PI) / sides;\n let rad = rotation * RAD_PER_DEG;\n for (let i = 0; i < sides; i++, rad += angle) {\n const sin = Math.sin(rad);\n const cos = Math.cos(rad);\n elements.push({\n type: 'point',\n optionScope: 'point',\n properties: {\n x: x + sin * radius,\n y: y - cos * radius,\n bX: x + sin * (radius + halfBorder),\n bY: y - cos * (radius + halfBorder)\n }\n });\n }\n return {x, y, width, height, elements, initProperties: {x, y}};\n }\n}\n\nPolygonAnnotation.id = 'polygonAnnotation';\n\nPolygonAnnotation.defaults = {\n adjustScaleRange: true,\n backgroundShadowColor: 'transparent',\n borderCapStyle: 'butt',\n borderDash: [],\n borderDashOffset: 0,\n borderJoinStyle: 'miter',\n borderShadowColor: 'transparent',\n borderWidth: 1,\n display: true,\n point: {\n radius: 0\n },\n radius: 10,\n rotation: 0,\n shadowBlur: 0,\n shadowOffsetX: 0,\n shadowOffsetY: 0,\n sides: 3,\n xAdjust: 0,\n xMax: undefined,\n xMin: undefined,\n xScaleID: 'x',\n xValue: undefined,\n yAdjust: 0,\n yMax: undefined,\n yMin: undefined,\n yScaleID: 'y',\n yValue: undefined\n};\n\nPolygonAnnotation.defaultRoutes = {\n borderColor: 'color',\n backgroundColor: 'color'\n};\n\n\nfunction pointIsInPolygon(points, x, y, useFinalPosition) {\n let isInside = false;\n let A = points[points.length - 1].getProps(['bX', 'bY'], useFinalPosition);\n for (const point of points) {\n const B = point.getProps(['bX', 'bY'], useFinalPosition);\n if ((B.bY > y) !== (A.bY > y) && x < (A.bX - B.bX) * (y - B.bY) / (A.bY - B.bY) + B.bX) {\n isInside = !isInside;\n }\n A = B;\n }\n return isInside;\n}\n\nconst annotationTypes = {\n box: BoxAnnotation,\n ellipse: EllipseAnnotation,\n label: LabelAnnotation,\n line: LineAnnotation,\n point: PointAnnotation,\n polygon: PolygonAnnotation\n};\n\n/**\n * Register fallback for annotation elements\n * For example lineAnnotation options would be looked through:\n * - the annotation object (options.plugins.annotation.annotations[id])\n * - element options (options.elements.lineAnnotation)\n * - element defaults (defaults.elements.lineAnnotation)\n * - annotation plugin defaults (defaults.plugins.annotation, this is what we are registering here)\n */\nObject.keys(annotationTypes).forEach(key => {\n defaults.describe(`elements.${annotationTypes[key].id}`, {\n _fallback: 'plugins.annotation'\n });\n});\n\nconst directUpdater = {\n update: Object.assign\n};\n\n/**\n * Resolve the annotation type, checking if is supported.\n * @param {string} [type=line] - annotation type\n * @returns {string} resolved annotation type\n */\nfunction resolveType(type = 'line') {\n if (annotationTypes[type]) {\n return type;\n }\n console.warn(`Unknown annotation type: '${type}', defaulting to 'line'`);\n return 'line';\n}\n\n/**\n * Create or update all annotation elements, configured to the plugin.\n * @param {Chart} chart - the chart where the plugin is enabled\n * @param {Object} state - the state of the plugin\n * @param {Object} options - annotation options to use\n * @param {UpdateMode} mode - The update mode\n */\nfunction updateElements(chart, state, options, mode) {\n const animations = resolveAnimations(chart, options.animations, mode);\n\n const annotations = state.annotations;\n const elements = resyncElements(state.elements, annotations);\n\n for (let i = 0; i < annotations.length; i++) {\n const annotationOptions = annotations[i];\n const element = getOrCreateElement(elements, i, annotationOptions.type);\n const resolver = annotationOptions.setContext(getContext(chart, element, annotationOptions));\n const properties = element.resolveElementProperties(chart, resolver);\n\n properties.skip = toSkip(properties);\n\n if ('elements' in properties) {\n updateSubElements(element, properties, resolver, animations);\n // Remove the sub-element definitions from properties, so the actual elements\n // are not overwritten by their definitions\n delete properties.elements;\n }\n\n if (!defined(element.x)) {\n // If the element is newly created, assing the properties directly - to\n // make them readily awailable to any scriptable options. If we do not do this,\n // the properties retruned by `resolveElementProperties` are available only\n // after options resolution.\n Object.assign(element, properties);\n }\n\n properties.options = resolveAnnotationOptions(resolver);\n\n animations.update(element, properties);\n }\n}\n\nfunction toSkip(properties) {\n return isNaN(properties.x) || isNaN(properties.y);\n}\n\nfunction resolveAnimations(chart, animOpts, mode) {\n if (mode === 'reset' || mode === 'none' || mode === 'resize') {\n return directUpdater;\n }\n return new Animations(chart, animOpts);\n}\n\nfunction updateSubElements(mainElement, {elements, initProperties}, resolver, animations) {\n const subElements = mainElement.elements || (mainElement.elements = []);\n subElements.length = elements.length;\n for (let i = 0; i < elements.length; i++) {\n const definition = elements[i];\n const properties = definition.properties;\n const subElement = getOrCreateElement(subElements, i, definition.type, initProperties);\n const subResolver = resolver[definition.optionScope].override(definition);\n properties.options = resolveAnnotationOptions(subResolver);\n animations.update(subElement, properties);\n }\n}\n\nfunction getOrCreateElement(elements, index, type, initProperties) {\n const elementClass = annotationTypes[resolveType(type)];\n let element = elements[index];\n if (!element || !(element instanceof elementClass)) {\n element = elements[index] = new elementClass();\n if (isObject(initProperties)) {\n Object.assign(element, initProperties);\n }\n }\n return element;\n}\n\nfunction resolveAnnotationOptions(resolver) {\n const elementClass = annotationTypes[resolveType(resolver.type)];\n const result = {};\n result.id = resolver.id;\n result.type = resolver.type;\n result.drawTime = resolver.drawTime;\n Object.assign(result,\n resolveObj(resolver, elementClass.defaults),\n resolveObj(resolver, elementClass.defaultRoutes));\n for (const hook of hooks) {\n result[hook] = resolver[hook];\n }\n return result;\n}\n\nfunction resolveObj(resolver, defs) {\n const result = {};\n for (const prop of Object.keys(defs)) {\n const optDefs = defs[prop];\n const value = resolver[prop];\n result[prop] = isObject(optDefs) ? resolveObj(value, optDefs) : value;\n }\n return result;\n}\n\nfunction getContext(chart, element, annotation) {\n return element.$context || (element.$context = Object.assign(Object.create(chart.getContext()), {\n element,\n id: annotation.id,\n type: 'annotation'\n }));\n}\n\nfunction resyncElements(elements, annotations) {\n const count = annotations.length;\n const start = elements.length;\n\n if (start < count) {\n const add = count - start;\n elements.splice(start, 0, ...new Array(add));\n } else if (start > count) {\n elements.splice(count, start - count);\n }\n return elements;\n}\n\nvar name = \"chartjs-plugin-annotation\";\nvar version = \"1.4.0\";\n\nconst chartStates = new Map();\n\nvar annotation = {\n id: 'annotation',\n\n version,\n\n /* TODO: enable in v2\n beforeRegister() {\n requireVersion('chart.js', '3.7', Chart.version);\n },\n */\n\n afterRegister() {\n Chart.register(annotationTypes);\n\n // TODO: Remove this check, warning and workaround in v2\n if (!requireVersion('chart.js', '3.7', Chart.version, false)) {\n console.warn(`${name} has known issues with chart.js versions prior to 3.7, please consider upgrading.`);\n\n // Workaround for https://github.com/chartjs/chartjs-plugin-annotation/issues/572\n Chart.defaults.set('elements.lineAnnotation', {\n callout: {},\n font: {},\n padding: 6\n });\n }\n },\n\n afterUnregister() {\n Chart.unregister(annotationTypes);\n },\n\n beforeInit(chart) {\n chartStates.set(chart, {\n annotations: [],\n elements: [],\n visibleElements: [],\n listeners: {},\n listened: false,\n moveListened: false\n });\n },\n\n beforeUpdate(chart, args, options) {\n const state = chartStates.get(chart);\n const annotations = state.annotations = [];\n\n let annotationOptions = options.annotations;\n if (isObject(annotationOptions)) {\n Object.keys(annotationOptions).forEach(key => {\n const value = annotationOptions[key];\n if (isObject(value)) {\n value.id = key;\n annotations.push(value);\n }\n });\n } else if (isArray(annotationOptions)) {\n annotations.push(...annotationOptions);\n }\n verifyScaleOptions(annotations, chart.scales);\n },\n\n afterDataLimits(chart, args) {\n const state = chartStates.get(chart);\n adjustScaleRange(chart, args.scale, state.annotations.filter(a => a.display && a.adjustScaleRange));\n },\n\n afterUpdate(chart, args, options) {\n const state = chartStates.get(chart);\n updateListeners(chart, state, options);\n updateElements(chart, state, options, args.mode);\n state.visibleElements = state.elements.filter(el => !el.skip && el.options.display);\n },\n\n beforeDatasetsDraw(chart, _args, options) {\n draw(chart, 'beforeDatasetsDraw', options.clip);\n },\n\n afterDatasetsDraw(chart, _args, options) {\n draw(chart, 'afterDatasetsDraw', options.clip);\n },\n\n beforeDraw(chart, _args, options) {\n draw(chart, 'beforeDraw', options.clip);\n },\n\n afterDraw(chart, _args, options) {\n draw(chart, 'afterDraw', options.clip);\n },\n\n beforeEvent(chart, args, options) {\n const state = chartStates.get(chart);\n handleEvent(state, args.event, options);\n },\n\n destroy(chart) {\n chartStates.delete(chart);\n },\n\n _getState(chart) {\n return chartStates.get(chart);\n },\n\n defaults: {\n animations: {\n numbers: {\n properties: ['x', 'y', 'x2', 'y2', 'width', 'height', 'pointX', 'pointY', 'labelX', 'labelY', 'labelWidth', 'labelHeight', 'radius'],\n type: 'number'\n },\n },\n clip: true,\n dblClickSpeed: 350, // ms\n drawTime: 'afterDatasetsDraw',\n label: {\n drawTime: null\n }\n },\n\n descriptors: {\n _indexable: false,\n _scriptable: (prop) => !hooks.includes(prop),\n annotations: {\n _allKeys: false,\n _fallback: (prop, opts) => `elements.${annotationTypes[resolveType(opts.type)].id}`,\n },\n },\n\n additionalOptionScopes: ['']\n};\n\nfunction draw(chart, caller, clip) {\n const {ctx, chartArea} = chart;\n const {visibleElements} = chartStates.get(chart);\n\n if (clip) {\n clipArea(ctx, chartArea);\n }\n\n drawElements(ctx, visibleElements, caller);\n drawSubElements(ctx, visibleElements, caller);\n\n if (clip) {\n unclipArea(ctx);\n }\n\n visibleElements.forEach(el => {\n if (!('drawLabel' in el)) {\n return;\n }\n const label = el.options.label;\n if (label && label.enabled && label.content && (label.drawTime || el.options.drawTime) === caller) {\n el.drawLabel(ctx, chartArea);\n }\n });\n}\n\nfunction drawElements(ctx, elements, caller) {\n for (const el of elements) {\n if (el.options.drawTime === caller) {\n el.draw(ctx);\n }\n }\n}\n\nfunction drawSubElements(ctx, elements, caller) {\n for (const el of elements) {\n if (isArray(el.elements)) {\n drawElements(ctx, el.elements, caller);\n }\n }\n}\n\nexport { annotation as default };\n","import data from \"./data.json\";\nimport Chart from \"chart.js/auto\";\nimport annotationPlugin from \"chartjs-plugin-annotation\";\n\nChart.register(annotationPlugin);\n\nfunction newShade(hexColor, magnitude) {\n hexColor = hexColor.replace(`#`, ``);\n if (hexColor.length === 6) {\n const decimalColor = parseInt(hexColor, 16);\n let r = (decimalColor >> 16) + magnitude;\n r > 255 && (r = 255);\n r < 0 && (r = 0);\n let g = (decimalColor & 0x0000ff) + magnitude;\n g > 255 && (g = 255);\n g < 0 && (g = 0);\n let b = ((decimalColor >> 8) & 0x00ff) + magnitude;\n b > 255 && (b = 255);\n b < 0 && (b = 0);\n return `#${(g | (b << 8) | (r << 16)).toString(16)}`;\n } else {\n return hexColor;\n }\n}\n\nconst colors = [\n \"#8dd3c7\",\n \"#ffffb3\",\n \"#bebada\",\n \"#fb8072\",\n \"#80b1d3\",\n \"#fdb462\",\n \"#b3de69\",\n \"#fccde5\",\n \"#d9d9d9\",\n \"#bc80bd\",\n \"#ccebc5\",\n \"#ffed6f\",\n];\n\n// https://github.com/chartjs/chartjs-plugin-annotation/blob/752f7e0e6b83f7e606a87ed63720e014f91dd276/docs/samples/line/datasetBars.md?plain=1#L125-L136\nfunction indexToMin(index, datasetCount, datasetIndex) {\n if (datasetCount === 2 && datasetIndex === 1) {\n return index + 0.04;\n }\n return index - 0.36;\n}\n\nfunction indexToMax(index, datasetCount, datasetIndex) {\n if (datasetCount === 2 && datasetIndex === 0) {\n return index - 0.04;\n }\n return index + 0.36;\n}\n\nfunction indexToMid(index, datasetCount, datasetIndex) {\n if (datasetCount === 2) {\n if (datasetIndex === 0) {\n return index - 0.2;\n }\n return index + 0.2;\n }\n return index;\n}\n\nconst stdevLineColor = \"#888888\";\nfor (const graph in data) {\n const ctx = document.getElementById(`${graph}-chart`).getContext(\"2d\");\n const options = {\n animation: false,\n elements: {\n bar: {\n borderWidth: 1.5,\n },\n },\n parsing: {\n xAxisKey: \"id\",\n yAxisKey: \"avg\",\n },\n responsive: true,\n scales: {\n y: {\n beginAtZero: true,\n min: 0,\n title: { text: \"seconds\", display: true },\n },\n },\n plugins: {\n legend: false,\n tooltip: {\n callbacks: {\n label: function (context) {\n return [\n `avg: ${context.raw.avg}`,\n `max: ${context.raw.max}`,\n `min: ${context.raw.min}`,\n ];\n },\n },\n },\n },\n };\n\n data[graph].datasets[0].backgroundColor = [];\n data[graph].datasets[0].borderColor = [];\n data[graph].datasets[0].data.forEach(function (dataset, i) {\n data[graph].datasets[0].backgroundColor.push(colors[i]);\n data[graph].datasets[0].borderColor.push(newShade(colors[i], -50));\n });\n if (data[graph].datasets.length > 1) {\n data[graph].datasets[1].backgroundColor = [];\n data[graph].datasets[1].borderColor = [];\n data[graph].datasets[1].data.forEach(function (dataset, i) {\n data[graph].datasets[1].backgroundColor.push(newShade(colors[i], -30));\n data[graph].datasets[1].borderColor.push(newShade(colors[i], -65));\n });\n options.scales.x = {\n ticks: {\n callback: function (value, index, ticks) {\n return [data[graph].labels[index], \"cold / warm\"];\n },\n },\n };\n }\n\n // TODO: pass in max/min values to show variation in results\n options.plugins.annotation = { annotations: {} };\n for (let idx = 0; idx < data[graph].datasets.length; idx++) {\n for (let idx2 = 0; idx2 < data[graph].datasets[idx].data.length; idx2++) {\n options.plugins.annotation.annotations[`annotations-min-${idx}-${idx2}`] =\n {\n type: \"line\",\n borderColor: stdevLineColor,\n borderWidth: 1.5,\n xMax: indexToMax(idx2, data[graph].datasets.length, idx) - 0.25,\n xMin: indexToMin(idx2, data[graph].datasets.length, idx) + 0.25,\n xScaleID: \"x\",\n // random number between 0 and 100\n yMax: data[graph].datasets[idx].data[idx2].min,\n yMin: data[graph].datasets[idx].data[idx2].min,\n yScaleID: \"y\",\n };\n options.plugins.annotation.annotations[`annotations-max-${idx}-${idx2}`] =\n {\n type: \"line\",\n borderColor: stdevLineColor,\n borderWidth: 1.5,\n xMax: indexToMax(idx2, data[graph].datasets.length, idx) - 0.25,\n xMin: indexToMin(idx2, data[graph].datasets.length, idx) + 0.25,\n xScaleID: \"x\",\n // random number between 0 and 100\n yMax: data[graph].datasets[idx].data[idx2].max,\n yMin: data[graph].datasets[idx].data[idx2].max,\n yScaleID: \"y\",\n };\n const midLine = indexToMid(idx2, data[graph].datasets.length, idx);\n options.plugins.annotation.annotations[\n `annotations-vert-${idx}-${idx2}`\n ] = {\n type: \"line\",\n borderColor: stdevLineColor,\n borderWidth: 1.5,\n xMax: midLine,\n xMin: midLine,\n xScaleID: \"x\",\n // random number between 0 and 100\n yMax: data[graph].datasets[idx].data[idx2].max,\n yMin: data[graph].datasets[idx].data[idx2].min,\n yScaleID: \"y\",\n };\n }\n }\n new Chart(ctx, {\n type: \"bar\",\n data: data[graph],\n options: options,\n });\n}\n"],"names":["$8c325eebeb74625a$exports","JSON","parse","$8d27ca75da600b9c$export$43caf9889c228507","window","callback1","requestAnimationFrame","$8d27ca75da600b9c$export$b4171a6734a65d42","fn","thisArg","updateFn","updateArgs","args","Array","prototype","slice","call","ticking","args1","rest","apply","$8d27ca75da600b9c$export$2219238a014317b0","delay","timeout","clearTimeout","setTimeout","this","$8d27ca75da600b9c$export$34aec0b863436764","align","$8d27ca75da600b9c$export$3c2fa207a37baaea","start","end","$8d27ca75da600b9c$export$91c6e00c14e7e6fd","left","right","rtl","$8d27ca75da600b9c$export$890c4ad488842ce7","$8d27ca75da600b9c$export$555508cbc6add439","id","$8d27ca75da600b9c$export$342063e11d6c3cad","value","$8d27ca75da600b9c$export$8b22cf2602fb60ce","isArray","type","Object","toString","$8d27ca75da600b9c$export$23f2a1d2818174ef","$8d27ca75da600b9c$export$39b482c5e57630a8","Number","isFinite","$8d27ca75da600b9c$export$c4ce752e73470fba","defaultValue","$8d27ca75da600b9c$export$90a7f3efeed30595","$8d27ca75da600b9c$export$7ccc53e8f1e7dfc5","dimension","endsWith","parseFloat","$8d27ca75da600b9c$export$3722cfe417b6ed86","$8d27ca75da600b9c$export$a9c23c6ac3fc3eca","loopable","reverse","i","len","keys","length","$8d27ca75da600b9c$export$ee7c8ad385a60b7b","a0","a1","ilen","v0","v1","datasetIndex","index","$8d27ca75da600b9c$export$c03999cb2f36933f","source","map","target","create","klen","k","$8d27ca75da600b9c$var$isValidKey","key","indexOf","$8d27ca75da600b9c$export$2ed0fc6709e59212","options","tval","sval","$8d27ca75da600b9c$export$6559d589eb85fbb6","sources","merger","$8d27ca75da600b9c$export$7910e0436ed8d1de","$8d27ca75da600b9c$export$f96d196f7728bb5","hasOwnProperty","$8d27ca75da600b9c$var$indexOfDotOrLength","idx","$8d27ca75da600b9c$export$2d1720544b23b823","obj","pos","$8d27ca75da600b9c$export$efca4cbe5dd06740","str","charAt","toUpperCase","$8d27ca75da600b9c$export$35e795649ee09318","$8d27ca75da600b9c$export$2e2af4578d910ddf","$8d27ca75da600b9c$export$c9170ad7d4cd7e57","a","b","size","item","has","$8d27ca75da600b9c$export$995eb9fca571757","e","$8d27ca75da600b9c$export$56c0d5a1e737357d","Math","PI","$8d27ca75da600b9c$export$971d5caa766a69d7","$8d27ca75da600b9c$export$e171bab687b50e0","$8d27ca75da600b9c$export$527e9aa3390079e9","POSITIVE_INFINITY","$8d27ca75da600b9c$export$a17c37559e1db147","$8d27ca75da600b9c$export$7f8ddf7c7c20b3cd","$8d27ca75da600b9c$export$fef3dfd9bad05307","$8d27ca75da600b9c$export$8c78c7c36408ea29","$8d27ca75da600b9c$export$3a1a48c8f6ef640e","log10","$8d27ca75da600b9c$export$2408f22a0fab9ae5","sign","$8d27ca75da600b9c$export$cf2f7c5792f80b46","range","roundedRange","round","$8d27ca75da600b9c$export$a33b77bbdbb8366c","niceRange","pow","floor","fraction","$8d27ca75da600b9c$export$a07804094c3ecf2d","result","sqrt","push","sort","pop","$8d27ca75da600b9c$export$9e5f44173e64f162","n","isNaN","x","y","epsilon","abs","$8d27ca75da600b9c$export$53a70dd1ebbae346","rounded","$8d27ca75da600b9c$export$158acd800e1ef08b","array","property","min","max","$8d27ca75da600b9c$export$625550452a3fa3ec","degrees","$8d27ca75da600b9c$export$25ce5a424b770e84","radians","$8d27ca75da600b9c$export$b9a6b53f9be3734","p","$8d27ca75da600b9c$export$e7094788287c5e9b","centrePoint","anglePoint","distanceFromXCenter","distanceFromYCenter","radialDistanceFromCenter","angle","atan2","distance","$8d27ca75da600b9c$export$24baa2b76016ce0e","pt1","pt2","$8d27ca75da600b9c$export$d29e374196577086","$8d27ca75da600b9c$export$9fa96a7d116ea3ce","$8d27ca75da600b9c$export$ffb5f4729a158638","sameAngleIsFullCircle","s","angleToStart","angleToEnd","startToAngle","endToAngle","$8d27ca75da600b9c$export$efccba1c4a2ef57b","$8d27ca75da600b9c$export$f38c853ae54ed474","$8d27ca75da600b9c$var$atEdge","t","$8d27ca75da600b9c$var$elasticIn","sin","$8d27ca75da600b9c$var$elasticOut","$8d27ca75da600b9c$export$f1e1789686576879","linear","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInSine","cos","easeOutSine","easeInOutSine","easeInExpo","easeOutExpo","easeInOutExpo","easeInCirc","easeOutCirc","easeInOutCirc","easeInElastic","easeOutElastic","easeInOutElastic","easeInBack","easeOutBack","easeInOutBack","easeInBounce","easeOutBounce","m","d","easeInOutBounce","$8d27ca75da600b9c$var$round","v","$8d27ca75da600b9c$var$lim","l","h","$8d27ca75da600b9c$var$p2b","$8d27ca75da600b9c$var$n2b","$8d27ca75da600b9c$var$b2n","$8d27ca75da600b9c$var$n2p","$8d27ca75da600b9c$var$map$1","A","B","C","D","E","F","c","f","$8d27ca75da600b9c$var$hex","$8d27ca75da600b9c$var$h1","$8d27ca75da600b9c$var$h2","$8d27ca75da600b9c$var$eq","$8d27ca75da600b9c$var$hexString","r","g","$8d27ca75da600b9c$var$isShort","$8d27ca75da600b9c$var$alpha","undefined","$8d27ca75da600b9c$var$HUE_RE","$8d27ca75da600b9c$var$hsl2rgbn","$8d27ca75da600b9c$var$hsv2rgbn","$8d27ca75da600b9c$var$hwb2rgbn","w","rgb","$8d27ca75da600b9c$var$rgb2hsl","$8d27ca75da600b9c$var$hueValue","$8d27ca75da600b9c$var$calln","$8d27ca75da600b9c$var$hsl2rgb","$8d27ca75da600b9c$var$hue","$8d27ca75da600b9c$var$hueParse","exec","p1","p2","$8d27ca75da600b9c$var$hwb2rgb","$8d27ca75da600b9c$var$hsv2rgb","$8d27ca75da600b9c$var$map","Z","Y","X","W","V","U","T","S","R","Q","P","O","N","M","L","K","G","H","I","J","$8d27ca75da600b9c$var$names$1","OiceXe","antiquewEte","aqua","aquamarRe","azuY","beige","bisque","black","blanKedOmond","Xe","XeviTet","bPwn","burlywood","caMtXe","KartYuse","KocTate","cSO","cSnflowerXe","cSnsilk","crimson","cyan","xXe","xcyan","xgTMnPd","xWay","xgYF","xgYy","xkhaki","xmagFta","xTivegYF","xSange","xScEd","xYd","xsOmon","xsHgYF","xUXe","xUWay","xUgYy","xQe","xviTet","dAppRk","dApskyXe","dimWay","dimgYy","dodgerXe","fiYbrick","flSOwEte","foYstWAn","fuKsia","gaRsbSo","ghostwEte","gTd","gTMnPd","Way","gYF","gYFLw","gYy","honeyMw","hotpRk","RdianYd","Rdigo","ivSy","khaki","lavFMr","lavFMrXsh","lawngYF","NmoncEffon","ZXe","ZcSO","Zcyan","ZgTMnPdLw","ZWay","ZgYF","ZgYy","ZpRk","ZsOmon","ZsHgYF","ZskyXe","ZUWay","ZUgYy","ZstAlXe","ZLw","lime","limegYF","lRF","magFta","maPon","VaquamarRe","VXe","VScEd","VpurpN","VsHgYF","VUXe","VsprRggYF","VQe","VviTetYd","midnightXe","mRtcYam","mistyPse","moccasR","navajowEte","navy","Tdlace","Tive","TivedBb","Sange","SangeYd","ScEd","pOegTMnPd","pOegYF","pOeQe","pOeviTetYd","papayawEp","pHKpuff","peru","pRk","plum","powMrXe","purpN","YbeccapurpN","Yd","Psybrown","PyOXe","saddNbPwn","sOmon","sandybPwn","sHgYF","sHshell","siFna","silver","skyXe","UXe","UWay","UgYy","snow","sprRggYF","stAlXe","tan","teO","tEstN","tomato","Qe","viTet","JHt","wEte","wEtesmoke","Lw","LwgYF","$8d27ca75da600b9c$var$names","$8d27ca75da600b9c$var$nameParse","unpacked","tkeys","j","ok","nk","replace","parseInt","$8d27ca75da600b9c$var$unpack","transparent","toLowerCase","$8d27ca75da600b9c$var$RGB_RE","$8d27ca75da600b9c$var$to","$8d27ca75da600b9c$var$from","$8d27ca75da600b9c$var$modHSL","ratio","tmp","$8d27ca75da600b9c$var$clone","proto","assign","$8d27ca75da600b9c$var$fromObject","input","$8d27ca75da600b9c$var$functionParse","$8d27ca75da600b9c$var$rgbParse","$8d27ca75da600b9c$var$Color","constructor","ret","_rgb","_valid","valid","rgbString","hexString","hslString","$8d27ca75da600b9c$var$hslString","mix","color1","weight","c1","c2","w2","w1","interpolate","color2","rgb1","rgb2","$8d27ca75da600b9c$var$interpolate","clone","alpha","clearer","greyscale","val","opaquer","negate","lighten","darken","saturate","desaturate","rotate","deg","$8d27ca75da600b9c$var$rotate","$8d27ca75da600b9c$var$index_esm","$8d27ca75da600b9c$export$9f4f30ee63539e24","$8d27ca75da600b9c$export$db3b6bfb95261072","$8d27ca75da600b9c$export$faec65b429be379","$8d27ca75da600b9c$export$ce26c07117d59d6a","$8d27ca75da600b9c$export$a8550f7dbe79f93a","$8d27ca75da600b9c$var$getScope$1","node","split","$8d27ca75da600b9c$var$set","root","scope","values","$8d27ca75da600b9c$export$4368d992c4eafac0","_descriptors1","animation","backgroundColor","borderColor","color","datasets","devicePixelRatio","context","chart","platform","getDevicePixelRatio","elements","events","font","family","style","lineHeight","hover","hoverBackgroundColor","ctx","hoverBorderColor","hoverColor","indexAxis","interaction","mode","intersect","includeInvisible","maintainAspectRatio","onHover","onClick","parsing","plugins","responsive","scale","scales","showLine","drawActiveElementsOnTop","describe","set","get","override","route","name","targetScope","targetName","scopeObject","targetScopeObject","privateName","defineProperties","writable","enumerable","local","_scriptable","startsWith","_indexable","_fallback","$8d27ca75da600b9c$export$3a6d5c9ae78a2c08","data","gc","longest","string","textWidth","measureText","width","$8d27ca75da600b9c$export$a05254e7c3aeba6e","arrayOfThings","cache","garbageCollect","save","jlen","thing","nestedThing","restore","gcLen","splice","$8d27ca75da600b9c$export$71cec2538cb2c617","pixel","currentDevicePixelRatio","halfWidth","$8d27ca75da600b9c$export$f787f51d84a910ad","canvas","getContext","resetTransform","clearRect","height","$8d27ca75da600b9c$export$6554612db691658e","xOffset","yOffset","cornerRadius","pointStyle","rotation","radius","rad","translate","drawImage","beginPath","arc","closePath","moveTo","lineTo","SQRT1_2","rect","fill","borderWidth","stroke","$8d27ca75da600b9c$export$ef35774e6d314e91","point","area","margin","top","bottom","$8d27ca75da600b9c$export$78acf4525d8a74c4","clip","$8d27ca75da600b9c$export$dc98b0b04f4c7758","$8d27ca75da600b9c$export$8a5498727ef6be21","previous","flip","midpoint","$8d27ca75da600b9c$export$d24c54395ce0c509","bezierCurveTo","cp1x","cp2x","cp1y","cp2y","$8d27ca75da600b9c$export$8743009a87fcb00f","text","opts","lines","strokeWidth","strokeColor","line","translation","fillStyle","textAlign","textBaseline","$8d27ca75da600b9c$var$setRenderOpts","strokeStyle","lineWidth","strokeText","maxWidth","fillText","$8d27ca75da600b9c$var$decorateText","strikethrough","underline","metrics","actualBoundingBoxLeft","actualBoundingBoxRight","actualBoundingBoxAscent","actualBoundingBoxDescent","yDecoration","decorationWidth","$8d27ca75da600b9c$export$493d36ec626b6698","topLeft","bottomLeft","bottomRight","topRight","$8d27ca75da600b9c$var$LINE_HEIGHT","RegExp","$8d27ca75da600b9c$var$FONT_STYLE","$8d27ca75da600b9c$export$1a8f5705751d8277","matches","match","$8d27ca75da600b9c$export$3b513254972cfc9c","props","objProps","read","prop","prop1","$8d27ca75da600b9c$export$1fbe638ecf81657e","$8d27ca75da600b9c$export$d66dc83d8cfc8dd","$8d27ca75da600b9c$export$96f57966bedc81b4","$8d27ca75da600b9c$export$3d8c2f653ac9d0b9","fallback","console","warn","$8d27ca75da600b9c$export$d377dcb2b61d6c4e","$8d27ca75da600b9c$export$407448d2b89b1813","inputs","info","cacheable","$8d27ca75da600b9c$export$db202ddc8be9136","minmax","grace","beginAtZero","change","keepZero","add","$8d27ca75da600b9c$export$dda1d9f60106f0e9","parentContext","$8d27ca75da600b9c$export$91477dc880baac21","table","cmp","mid","hi","lo","$8d27ca75da600b9c$export$d141bba7fdc215a3","$8d27ca75da600b9c$export$ebd11618f299a286","$8d27ca75da600b9c$export$23ebac1979863676","$8d27ca75da600b9c$var$arrayEvents","$8d27ca75da600b9c$export$3b14a55fb2447963","listener","stub","_chartjs","listeners","forEach","$8d27ca75da600b9c$export$71511d61b312f219","items","set1","Set","from","$8d27ca75da600b9c$export$c3950d9923825c02","scopes","prefixes","rootScopes","getTarget","$8d27ca75da600b9c$var$_resolve","Symbol","toStringTag","_cacheable","_scopes","_rootScopes","_getTarget","Proxy","deleteProperty","_keys","$8d27ca75da600b9c$var$_cached","proxy","prefix","$8d27ca75da600b9c$var$readKey","$8d27ca75da600b9c$var$needsSubResolver","$8d27ca75da600b9c$var$createSubResolver","$8d27ca75da600b9c$var$_resolveWithPrefixes","getOwnPropertyDescriptor","Reflect","getPrototypeOf","$8d27ca75da600b9c$var$getKeysFromAllScopes","includes","ownKeys","storage","_storage","$8d27ca75da600b9c$export$a93c5207d687da10","subProxy","descriptorDefaults","_proxy","_context","_subProxy","_stack","_descriptors","$8d27ca75da600b9c$export$a9c996f45e5784d0","setContext","receiver","descriptors1","isScriptable","Error","join","delete","$8d27ca75da600b9c$var$_resolveScriptable","isIndexable","descriptors2","arr","filter","resolver","$8d27ca75da600b9c$var$_resolveArray","$8d27ca75da600b9c$var$_resolveWithContext","allKeys","configurable","defaults1","scriptable","indexable","_allKeys","resolve1","$8d27ca75da600b9c$var$resolveFallback","$8d27ca75da600b9c$var$getScope","parent","$8d27ca75da600b9c$var$addScopes","set2","parentScopes","parentFallback","allScopes","set3","$8d27ca75da600b9c$var$addScopesFromKey","$8d27ca75da600b9c$var$subGetTarget","set4","set5","$8d27ca75da600b9c$var$resolveKeysFromAllScopes","$8d27ca75da600b9c$export$4a5767248b18ef41","meta","count","iScale","_parsing","parsed","$8d27ca75da600b9c$var$EPSILON","EPSILON","$8d27ca75da600b9c$var$getPoint","points","skip","$8d27ca75da600b9c$var$getValueAxis","$8d27ca75da600b9c$export$667d3bf0c5f83305","firstPoint","middlePoint","afterPoint","current","next","d01","d12","s01","s12","fa","fb","$8d27ca75da600b9c$export$317a3d46287192d8","valueAxis","pointsLen","deltaK","mK","pointBefore","pointCurrent","pointAfter","slopeDelta","alphaK","betaK","tauK","squaredMagnitude","$8d27ca75da600b9c$var$monotoneAdjust","delta","iPixel","vPixel","$8d27ca75da600b9c$var$monotoneCompute","$8d27ca75da600b9c$var$capControlPoint","pt","$8d27ca75da600b9c$export$21579262ef46735b","loop","controlPoints","spanGaps","cubicInterpolationMode","prev","tension","capBezierPoints","inArea","inAreaPrev","inAreaNext","$8d27ca75da600b9c$var$capBezierPoints","$8d27ca75da600b9c$export$61196ced6d74a310","document","$8d27ca75da600b9c$export$2329c99376c9d0a4","domNode","parentNode","host","$8d27ca75da600b9c$var$parseMaxStyle","styleValue","parentProperty","valueInPixels","$8d27ca75da600b9c$var$getComputedStyle","element","getComputedStyle","$8d27ca75da600b9c$var$positions","$8d27ca75da600b9c$var$getPositionedStyle","styles","suffix","$8d27ca75da600b9c$export$df995fae86a55f06","evt","borderBox","boxSizing","paddings","borders","box","touches","offsetX","offsetY","shadowRoot","$8d27ca75da600b9c$var$useOffsetPos","getBoundingClientRect","clientX","clientY","$8d27ca75da600b9c$var$getCanvasPosition","$8d27ca75da600b9c$var$round1","$8d27ca75da600b9c$export$d66501df72047452","bbWidth","bbHeight","aspectRatio","margins","maxHeight","containerSize","container","containerStyle","containerBorder","containerPadding","clientWidth","clientHeight","$8d27ca75da600b9c$var$getContainerSize","$8d27ca75da600b9c$export$4c3d22f3d993c33f","forceRatio","forceStyle","pixelRatio","deviceHeight","deviceWidth","setTransform","$8d27ca75da600b9c$export$3466f893ebf79586","passiveSupported","passive","addEventListener","removeEventListener","$8d27ca75da600b9c$export$9bb611d729802a56","el","getPropertyValue","$8d27ca75da600b9c$export$1ee57be6f6687d2c","$8d27ca75da600b9c$export$2f6ca3d3b1f80bf5","$8d27ca75da600b9c$export$306ddfe3a8403e2","$8d27ca75da600b9c$export$7a38258bbe170828","cp1","cp2","$8d27ca75da600b9c$var$intlCache","Map","$8d27ca75da600b9c$export$ae1af26003f05816","num","locale","cacheKey","stringify","formatter","Intl","NumberFormat","$8d27ca75da600b9c$var$getNumberFormat","format","$8d27ca75da600b9c$export$28f7fcd39efa255","rectX","setWidth","xPlus","leftForLtr","itemWidth","$8d27ca75da600b9c$var$getRightToLeftAdapter","_itemWidth","$8d27ca75da600b9c$export$3d12bd131bb975d1","direction","original","getPropertyPriority","setProperty","prevTextDirection","$8d27ca75da600b9c$export$9d398bebfec1c039","$8d27ca75da600b9c$var$propertyFn","between","compare","normalize","$8d27ca75da600b9c$var$normalizeSegment","$8d27ca75da600b9c$export$92108d983e8ee699","segment","bounds","startBound","endBound","$8d27ca75da600b9c$var$getSegment","prevValue","inside","subStart","shouldStart","shouldStop","$8d27ca75da600b9c$export$1a82df3d29112e01","segments","sub","$8d27ca75da600b9c$export$ab83b03e4111b1d0","segmentOptions","_loop","$8d27ca75da600b9c$var$findStartAndEnd","$8d27ca75da600b9c$var$splitByStyles","last","cur","stop","$8d27ca75da600b9c$var$solidSegments","_fullLoop","chartContext","_chart","baseStyle","$8d27ca75da600b9c$var$readStyle","_datasetIndex","prevStyle","addStyle","st","dir","p0","p0DataIndex","p1DataIndex","$8d27ca75da600b9c$var$styleChanged","$8d27ca75da600b9c$var$doSplitByStyles","borderCapStyle","borderDash","borderDashOffset","borderJoinStyle","$2e9bc5022d60fc00$export$a424a0aa8f687495","_request","_charts","_running","_lastDate","_notify","anims","date","callbacks","numSteps","duration","initial","currentStep","_refresh","_update","Date","now","remaining","running","draw1","_active","_total","tick","draw","_getAnims","charts","complete","progress","listen","event","cb","reduce","acc","_duration","cancel","remove","$2e9bc5022d60fc00$var$interpolators","boolean","to","factor","c0","number","$2e9bc5022d60fc00$export$c35d437ae5945fcd","cfg","currentValue","_fn","_easing","easing","_start","_target","_prop","_from","_to","_promises","active","update","elapsed","remain","wait","promises","Promise","res","rej","resolved","method","$2e9bc5022d60fc00$var$animationOptions","colors","properties","numbers","resize","show","animations","visible","hide","$2e9bc5022d60fc00$export$8ab227dac26677d","config","_properties","configure","animatedProps","getOwnPropertyNames","option","_animateOptions","newOptions","$shared","$animations","$2e9bc5022d60fc00$var$resolveTargetOptions","_createAnimations","anim","all","$2e9bc5022d60fc00$var$awaitAll","then","$2e9bc5022d60fc00$var$scaleClip","allowedOverflow","$2e9bc5022d60fc00$var$getSortedDatasetIndices","filterVisible","metasets","_getSortedDatasetMetas","$2e9bc5022d60fc00$var$applyStack","stack","dsIndex","singleMode","otherValue","$2e9bc5022d60fc00$var$isStacked","stacked","$2e9bc5022d60fc00$var$getOrCreateStack","stacks","stackKey","indexValue","subStack","$2e9bc5022d60fc00$var$getLastIndexInStack","vScale","positive","getMatchingVisibleMetas","$2e9bc5022d60fc00$var$updateStacks","controller","_cachedMeta","_stacks","iAxis","axis","vAxis","indexScale","valueScale","$2e9bc5022d60fc00$var$getStackKey","index1","_top","_bottom","$2e9bc5022d60fc00$var$getFirstScaleId","scales1","shift","$2e9bc5022d60fc00$var$clearStacks","_parsed","$2e9bc5022d60fc00$var$isDirectUpdateMode","$2e9bc5022d60fc00$var$cloneIfNotShared","cached","shared","$2e9bc5022d60fc00$export$75572ec5c55b4048","_ctx","_cachedDataOpts","getMeta","_type","_data","_objectData","_sharedOptions","_drawStart","_drawCount","enableOptionSharing","supportsDecimation","$context","_syncList","initialize","linkScales","_stacked","addElements","updateIndex","dataset","getDataset","chooseId","xid","xAxisID","yid","yAxisID","rid","rAxisID","iid","iAxisID","vid","vAxisID","xScale","getScaleForId","yScale","rScale","getDatasetMeta","scaleID","_getOtherScale","reset","_destroy","_dataCheck","adata","$2e9bc5022d60fc00$var$convertObjectDataToArray","isExtensible","defineProperty","base","object","datasetElementType","buildOrUpdateElements","resetNewElements","stackChanged","oldStacked","_resyncElements","scopeKeys","datasetScopeKeys","getOptionScopes","createResolver","sorted","_sorted","parseArrayData","parseObjectData","parsePrimitiveData","isNotInOrderComparedToPrev","labels","getLabels","singleScale","index4","index5","xAxisKey","yAxisKey","index6","getParsed","index7","getDataElement","index8","applyStack","updateRangeFromParsed","parsedValue","NaN","getMinMax","canStack","otherScale","hidden","$2e9bc5022d60fc00$var$createStack","NEGATIVE_INFINITY","otherMin","otherMax","minDefined","maxDefined","getUserBounds","$2e9bc5022d60fc00$var$getUserBounds","_skip","getAllParsedValues","getMaxOverflow","getLabelAndValue","index9","label","getLabelForValue","_clip","disabled","$2e9bc5022d60fc00$var$toClip","$2e9bc5022d60fc00$var$defaultClip","elements1","chartArea","getStyle","index10","resolveDatasetElementOptions","resolveDataElementOptions","index11","index3","dataIndex","raw","$2e9bc5022d60fc00$var$createDataContext","index2","_resolveElementOptions","index12","dataElementType","elementType","index13","sharing","datasetElementScopeKeys","names","resolveNamedOptions","freeze","_resolveAnimations","index14","transition","datasetAnimationScopeKeys","getSharedOptions","includeOptions","sharedOptions","_animationsDisabled","updateElement","index15","updateSharedOptions","_setStyle","index16","removeHoverStyle","index17","setHoverStyle","index18","_removeDatasetHoverStyle","_setDatasetHoverStyle","elements2","arg1","arg2","numMeta","numData","_insertElements","_removeElements","move","updateElements","removed","_sync","_dataChanges","_onDataPush","arguments","_onDataPop","_onDataShift","_onDataSplice","newCount","_onDataUnshift","$2e9bc5022d60fc00$var$computeMinSampleSize","_cache","$bar","visibleMetas","concat","$2e9bc5022d60fc00$var$getAllScaleValues","curr","_length","updateMinAndPrev","getPixelForValue","ticks","getPixelForTick","$2e9bc5022d60fc00$var$parseValue","entry","startValue","endValue","barStart","barEnd","_custom","$2e9bc5022d60fc00$var$parseFloatBar","$2e9bc5022d60fc00$var$parseArrayOrPrimitive","$2e9bc5022d60fc00$var$isFloatBar","custom","$2e9bc5022d60fc00$var$setBorderSkipped","index21","edge","borderSkipped","horizontal","$2e9bc5022d60fc00$var$borderProps","enableBorderRadius","$2e9bc5022d60fc00$var$parseEdge","orig","v2","$2e9bc5022d60fc00$var$startEnd","$2e9bc5022d60fc00$var$setInflateAmount","inflateAmount","defaults","$2e9bc5022d60fc00$export$e97d5dc64e999004","iAxisKey","vAxisKey","super","index22","bars","index23","getBasePixel","isHorizontal","ruler","_getRuler","firstOpts","vpixels","head","_calculateBarValuePixels","ipixels","_calculateBarIndexPixels","center","_getStacks","grouped","_getStackCount","index24","_getStackIndex","index25","pixels","barThickness","_startPixel","_endPixel","stackCount","categoryPercentage","barPercentage","index26","baseValue","minBarLength","actualBase","floating","getDataVisibility","$2e9bc5022d60fc00$var$barSign","startPixel","getPixelForDecimal","endPixel","halfGrid","getLineWidthForValue","index27","skipNull","maxBarThickness","Infinity","index20","percent","chunk","$2e9bc5022d60fc00$var$computeFlexCategoryTraits","index19","thickness","$2e9bc5022d60fc00$var$computeFitCategoryTraits","stackIndex","rects","overrides","_index_","offset","grid","_value_","$2e9bc5022d60fc00$export$19b5c4773f17abe","index28","index29","tooltip","title","$2e9bc5022d60fc00$export$e04603e7d8b77172","innerRadius","outerRadius","i1","getter","_getRotation","_getCircumference","circumference","_getRotationExtents","isDatasetVisible","arcs","spacing","getMaxBorderWidth","getMaxOffset","maxSize","cutout","chartWeight","_getRingWeight","ratioX","ratioY","startAngle","endAngle","startX","startY","endX","endY","calcMax","calcMin","maxX","maxY","minX","minY","$2e9bc5022d60fc00$var$getRatioAndOffset","maxRadius","radiusLength","_getVisibleDatasetWeightTotal","total","calculateTotal","_getRingWeightOffset","_circumference","animateRotate","calculateCircumference","animationOpts","centerX","centerY","animateScale","metaData","index30","borderAlign","hoverBorderWidth","hoverOffset","ringWeightOffset","descriptors","legend","generateLabels","legendItem","toggleDataVisibility","tooltipItem","dataLabel","formattedValue","$2e9bc5022d60fc00$export$3c9b5d28c11cbfd0","_dataset","animationsDisabled","pointCount","$2e9bc5022d60fc00$var$getStartAndCountOfVisiblePoints","_scaleRanges","newRanges","xmin","xmax","ymin","ymax","changed","$2e9bc5022d60fc00$var$scaleRangesChanged","_decimated","animated","maxGapLength","directUpdate","prevParsed","nullData","border","lastPoint","updateControlPoints","$2e9bc5022d60fc00$export$2a270b3a0d973c85","index31","bind","_updateRadius","index32","minSize","cutoutPercentage","getVisibleDatasetCount","xCenter","yCenter","datasetStartAngle","getIndexAngle","defaultAngle","countVisibleElements","_computeAngle","getDistanceFromCenterForValue","index33","index34","angleLines","display","circular","pointLabels","$2e9bc5022d60fc00$export$b21a3f1286706191","$2e9bc5022d60fc00$export$48dbc6ac651bf8be","index35","pointPosition","getPointPositionForValue","$2e9bc5022d60fc00$export$b2f2bae6713db87","$2e9bc5022d60fc00$export$a6506504f799c5d5","__proto__","BarController","BubbleController","DoughnutController","LineController","PolarAreaController","PieController","RadarController","ScatterController","$2e9bc5022d60fc00$var$abstract","$2e9bc5022d60fc00$var$DateAdapter","formats","timestamp","amount","unit","diff","startOf","weekday","endOf","members","$2e9bc5022d60fc00$export$f32766ea09ec8bc4","_date","$2e9bc5022d60fc00$var$binarySearch","metaset","lookupMethod","_reversePixels","getRange","$2e9bc5022d60fc00$var$evaluateInteractionItems","position","handler","getSortedVisibleDatasetMetas","index36","$2e9bc5022d60fc00$var$getIntersectItems","useFinalPosition","isPointInArea","index37","inRange","$2e9bc5022d60fc00$var$getNearestCartesianItems","distanceMetric","useX","useY","deltaX","deltaY","$2e9bc5022d60fc00$var$getDistanceMetricForAxis","minDistance","index39","inRange1","getCenterPoint","$2e9bc5022d60fc00$var$getNearestItems","index38","getProps","$2e9bc5022d60fc00$var$getNearestRadialItems","$2e9bc5022d60fc00$var$getAxisItems","rangeMethod","intersectsItem","index40","$2e9bc5022d60fc00$export$a13296960cae0384","modes","elements3","index41","nearest","$2e9bc5022d60fc00$var$STATIC_POSITIONS","$2e9bc5022d60fc00$var$filterByPosition","$2e9bc5022d60fc00$var$filterDynamicPositionByAxis","$2e9bc5022d60fc00$var$sortByWeight","$2e9bc5022d60fc00$var$setLayoutDims","layouts2","params","layouts1","wrap","stackWeight","placed","$2e9bc5022d60fc00$var$buildStacks","vBoxMaxWidth","hBoxMaxHeight","layout","fullSize","availableWidth","availableHeight","$2e9bc5022d60fc00$var$getCombinedMax","maxPadding","$2e9bc5022d60fc00$var$updateMaxPadding","boxPadding","$2e9bc5022d60fc00$var$updateDims","getPadding","newWidth","outerWidth","newHeight","outerHeight","widthChanged","heightChanged","same","other","$2e9bc5022d60fc00$var$getMargins","marginForPositions","positions","$2e9bc5022d60fc00$var$fitBoxes","boxes","refitBoxes","refit","$2e9bc5022d60fc00$var$setBoxDims","$2e9bc5022d60fc00$var$placeBoxes","userPadding","padding","autoPadding","$2e9bc5022d60fc00$export$1ecca0613f5e56d2","addBox","_layers","z","removeBox","layoutItem","index42","minPadding","layoutBoxes","$2e9bc5022d60fc00$var$wrapBoxes","centerHorizontal","centerVertical","leftAndTop","rightAndBottom","vertical","$2e9bc5022d60fc00$var$buildLayoutBoxes","verticalBoxes","horizontalBoxes","beforeLayout","visibleVerticalBoxCount","updatePos","$2e9bc5022d60fc00$var$handleMaxPadding","$2e9bc5022d60fc00$export$7b1aeb87f31f7da8","acquireContext","releaseContext","getMaximumSize","isAttached","updateConfig","$2e9bc5022d60fc00$export$a40a96b24b46cf35","$2e9bc5022d60fc00$var$EVENT_TYPES","touchstart","touchmove","touchend","pointerenter","pointerdown","pointermove","pointerup","pointerleave","pointerout","$2e9bc5022d60fc00$var$isNullOrEmpty","$2e9bc5022d60fc00$var$eventListenerOptions","$2e9bc5022d60fc00$var$removeListener","$2e9bc5022d60fc00$var$nodeListContains","nodeList","contains","$2e9bc5022d60fc00$var$createAttachObserver","observer","MutationObserver","entries","trigger","addedNodes","removedNodes","observe","childList","subtree","$2e9bc5022d60fc00$var$createDetachObserver","$2e9bc5022d60fc00$var$drpListeningCharts","$2e9bc5022d60fc00$var$oldDevicePixelRatio","$2e9bc5022d60fc00$var$onWindowResize","dpr","$2e9bc5022d60fc00$var$createResizeObserver","ResizeObserver","contentRect","$2e9bc5022d60fc00$var$listenDevicePixelRatioChanges","$2e9bc5022d60fc00$var$releaseObserver","disconnect","$2e9bc5022d60fc00$var$unlistenDevicePixelRatioChanges","$2e9bc5022d60fc00$var$createProxyAndListen","native","$2e9bc5022d60fc00$var$fromNativeEvent","$2e9bc5022d60fc00$var$addListener","$2e9bc5022d60fc00$export$f02da7f882cf6b2e","renderHeight","getAttribute","renderWidth","displayWidth","displayHeight","$2e9bc5022d60fc00$var$initCanvas","removeAttribute","setAttribute","proxies","$proxies","attach","detach","isConnected","$2e9bc5022d60fc00$export$db77ccec0bb4ccac","tooltipPosition","hasValue","final","defaultRoutes","$2e9bc5022d60fc00$var$formatters","numeric","tickValue","notation","maxTick","$2e9bc5022d60fc00$var$calculateDelta","logDelta","numDecimal","minimumFractionDigits","maximumFractionDigits","logarithmic","index43","$2e9bc5022d60fc00$export$27c7467594ef87bd","$2e9bc5022d60fc00$var$autoSkip","tickOpts","ticksLimit","maxTicksLimit","tickLength","_tickSize","maxScale","maxChart","_maxLength","$2e9bc5022d60fc00$var$determineMaxTicks","majorIndices","major","enabled","$2e9bc5022d60fc00$var$getMajorIndices","numMajorIndices","first","newTicks","ceil","$2e9bc5022d60fc00$var$skipMajors","evenMajorSpacing","$2e9bc5022d60fc00$var$getEvenSpacing","factors","$2e9bc5022d60fc00$var$calculateSpacing","avgMajorSpacing","$2e9bc5022d60fc00$var$skip","majorStart","majorEnd","drawBorder","drawOnChartArea","drawTicks","tickWidth","tickColor","minRotation","maxRotation","mirror","textStrokeWidth","textStrokeColor","autoSkip","autoSkipPadding","labelOffset","callback","formatters","minor","crossAlign","showLabelBackdrop","backdropColor","backdropPadding","$2e9bc5022d60fc00$var$offsetFromEdge","$2e9bc5022d60fc00$var$sample","numItems","increment","$2e9bc5022d60fc00$var$getPixelForGridLine","index44","offsetGridLines","validIndex1","lineValue","$2e9bc5022d60fc00$var$getTickMarkLength","$2e9bc5022d60fc00$var$getTitleHeight","$2e9bc5022d60fc00$var$titleAlign","$2e9bc5022d60fc00$var$reverseAlign","$2e9bc5022d60fc00$export$d60cfc58d3c358b6","_margins","paddingTop","paddingBottom","paddingLeft","paddingRight","labelRotation","_range","_gridLineItems","_labelItems","_labelSizes","_longestTextCache","_userMax","_userMin","_suggestedMax","_suggestedMin","_ticksLength","_borderValue","_dataLimitsCached","init","suggestedMin","suggestedMax","metas","getTicks","xLabels","yLabels","beforeUpdate","sampleSize","beforeSetDimensions","setDimensions","afterSetDimensions","beforeDataLimits","determineDataLimits","afterDataLimits","beforeBuildTicks","buildTicks","afterBuildTicks","samplingEnabled","_convertTicksToLabels","beforeCalculateLabelRotation","calculateLabelRotation","afterCalculateLabelRotation","afterAutoSkip","beforeFit","fit","afterFit","afterUpdate","reversePixels","_alignToPixels","alignToPixels","_callHooks","notifyPlugins","beforeTickToLabelConversion","generateTickLabels","afterTickToLabelConversion","numTicks","maxLabelDiagonal","_isVisible","labelSizes","_getLabelSizes","maxLabelWidth","widest","maxLabelHeight","highest","asin","titleOpts","gridOpts","titleHeight","tickPadding","angleRadians","labelHeight","labelWidth","_calculatePadding","_handleMargins","isRotated","labelsBelowTicks","offsetLeft","offsetRight","isFullSize","_computeLabelSizes","caches","widths","heights","tickFont","fontString","nestedLabel","widestLabelSize","highestLabelSize","_resolveTickFontOptions","$2e9bc5022d60fc00$var$garbageCollect","valueAt","getValueForPixel","index46","decimal","getDecimalForPixel","getBaseValue","index47","index45","$2e9bc5022d60fc00$var$createTickContext","optionTicks","rot","_computeGridLineItems","ticksLength","tl","borderOpts","axisWidth","axisHalfWidth","alignBorderValue","borderValue","alignedLineValue","tx1","ty1","tx2","ty2","x1","y1","x2","y2","positionAxisID","limit","step","optsAtIndex","lineColor","tickBorderDash","tickBorderDashOffset","_computeLabelItems","tickAndPadding","hTickAndPadding","lineCount","textOffset","_getXAxisLabelAlignment","_getYAxisLabelAlignment","halfCount","backdrop","tickTextAlign","labelPadding","_computeLabelArea","drawBackground","fillRect","index48","findIndex","drawGrid","drawLine","setLineDash","lineDashOffset","lastLineWidth","drawLabels","drawTitle","titleX","titleY","scales2","$2e9bc5022d60fc00$var$titleArgs","tz","gz","axisID","index49","_maxDigits","fontSize","$2e9bc5022d60fc00$var$TypedRegistry","isForType","isPrototypeOf","register","parentScope","$2e9bc5022d60fc00$var$isIChartComponent","itemDefaults","routes","propertyParts","sourceName","sourceScope","parts","$2e9bc5022d60fc00$var$routeDefaults","$2e9bc5022d60fc00$var$registerDefaults","unregister","$2e9bc5022d60fc00$export$4bb7493d241fd8a5","controllers","_typedRegistries","_each","addControllers","addPlugins","addScales","getController","_get","getElement","getPlugin","getScale","removeControllers","removeElements","removePlugins","removeScales","typedRegistry","arg","reg","_getRegistryForType","_exec","itemReg","registry1","component","camelMethod","$2e9bc5022d60fc00$var$PluginService","_init","notify","hook","_createDescriptors","descriptor","plugin","cancelable","invalidate","_oldCache","descriptors3","_notifyStateChanges","plugins1","plugins2","i3","$2e9bc5022d60fc00$var$allPlugins","plugins3","$2e9bc5022d60fc00$var$getOpts","$2e9bc5022d60fc00$var$pluginOpts","$2e9bc5022d60fc00$var$createDescriptors","previousDescriptors","descriptors4","some","pluginScopeKeys","$2e9bc5022d60fc00$var$getIndexAxis","datasetDefaults","$2e9bc5022d60fc00$var$determineAxis","scaleOptions","$2e9bc5022d60fc00$var$initOptions","chartDefaults","configScales","chartIndexAxis","firstIDs","scales3","scaleConf","error","defaultId","$2e9bc5022d60fc00$var$getDefaultScaleIDFromAxis","defaultScaleOptions","defaultID","$2e9bc5022d60fc00$var$getAxisFromDefaultScaleID","$2e9bc5022d60fc00$var$mergeScaleConfig","$2e9bc5022d60fc00$var$initData","$2e9bc5022d60fc00$var$keyCache","$2e9bc5022d60fc00$var$keysCached","$2e9bc5022d60fc00$var$cachedKeys","generate","$2e9bc5022d60fc00$var$addIfFound","$2e9bc5022d60fc00$var$Config","_config","$2e9bc5022d60fc00$var$initConfig","_scopeCache","_resolverCache","clearCache","clear","datasetType","additionalOptionScopes","_cachedScopes","mainScope","resetCache","keyLists","chartOptionScopes","subPrefixes","$2e9bc5022d60fc00$var$getResolver","$2e9bc5022d60fc00$var$hasFunction","$2e9bc5022d60fc00$var$needContext","resolverCache","$2e9bc5022d60fc00$var$KNOWN_POSITIONS","$2e9bc5022d60fc00$var$positionIsHorizontal","$2e9bc5022d60fc00$var$compare2Level","l1","l2","$2e9bc5022d60fc00$var$onAnimationsComplete","animationOptions1","onComplete","$2e9bc5022d60fc00$var$onAnimationProgress","animationOptions2","onProgress","$2e9bc5022d60fc00$var$getCanvas","getElementById","$2e9bc5022d60fc00$var$instances","$2e9bc5022d60fc00$var$getChart","$2e9bc5022d60fc00$var$moveNumericKeys","intKey","$2e9bc5022d60fc00$export$acaa6426d77a227e","userConfig","initialCanvas","existingChart","OffscreenCanvas","$2e9bc5022d60fc00$export$72cd9e67b1b784f9","_options","_aspectRatio","_metasets","_lastEvent","_listeners","_responsiveListeners","_sortedMetasets","_plugins","_hiddenIndices","attached","_doResize","resizeDelay","_initialize","bindEvents","_resizeBeforeDraw","_resize","newSize","newRatio","onResize","render","ensureScalesHaveIDs","axisOptions","buildOrUpdateScales","scaleOpts","scales4","updated","isRadial","dposition","dtype","scaleType","hasUpdated","_updateMetasets","_destroyDatasetMeta","_removeUnreferencedMetasets","index50","buildOrUpdateControllers","newControllers","order","ControllerClass","_resetElements","animsDisabled","_updateScales","_checkEventBindings","_updateHiddenIndices","_minPadding","_updateLayout","_updateDatasets","_eventHandler","_updateHoverStyles","existingEvents","newEvents","unbindEvents","changes","_getUniformDataChanges","datasetCount","makeSet","changeSet","i4","noArea","index51","_idx","i5","ilen1","_updateDataset","index52","layers","_drawDatasets","_drawDataset","useClip","getElementsAtEventForMode","setDatasetVisibility","index53","index54","_updateVisibility","_stop","destroy","toBase64Image","toDataURL","bindUserEvents","bindResponsiveEvents","_add","listener1","_remove","listener2","detached","updateHoverStyle","getActiveElements","setActiveElements","activeElements","lastActive","index55","replay","hoverOptions","deactivated","activated","inChartArea","eventFilter","_handleEvent","_getActiveElements","isClick","lastEvent","$2e9bc5022d60fc00$var$determineLastEvent","$2e9bc5022d60fc00$var$invalidatePlugins","instances","$2e9bc5022d60fc00$var$clipArc","pixelMargin","angleMargin","$2e9bc5022d60fc00$var$parseBorderRadius$1","angleDelta","o","borderRadius","halfThickness","innerLimit","computeOuterLimit","outerArcLimit","outerStart","outerEnd","innerStart","innerEnd","$2e9bc5022d60fc00$var$rThetaToXY","theta","$2e9bc5022d60fc00$var$pathArc","innerR","spacingOffset","avNogSpacingRadius","angleOffset","outerStartAdjustedRadius","outerEndAdjustedRadius","outerStartAdjustedAngle","outerEndAdjustedAngle","innerStartAdjustedRadius","innerEndAdjustedRadius","innerStartAdjustedAngle","innerEndAdjustedAngle","pCenter","p4","p8","$2e9bc5022d60fc00$var$drawBorder","inner","lineJoin","fullCircles","$2e9bc5022d60fc00$var$drawFullCircleBorders","registry","version","getChart","$2e9bc5022d60fc00$export$d48203c759d6a1fc","chartX","chartY","rAdjust","betweenAngles","withinRadius","halfAngle","halfRadius","radiusOffset","$2e9bc5022d60fc00$var$drawArc","$2e9bc5022d60fc00$var$setStyle","lineCap","$2e9bc5022d60fc00$var$lineTo","$2e9bc5022d60fc00$var$pathVars","paramsStart","paramsEnd","segmentStart","segmentEnd","outside","$2e9bc5022d60fc00$var$pathSegment","lineMethod","stepped","$2e9bc5022d60fc00$var$getLineMethod","$2e9bc5022d60fc00$var$fastPathSegment","prevX","lastY","avgX","countX","pointIndex","index56","drawX","truncX","$2e9bc5022d60fc00$var$_getSegmentMethod","$2e9bc5022d60fc00$var$usePath2D","Path2D","$2e9bc5022d60fc00$var$draw","path","_path","$2e9bc5022d60fc00$var$strokePathWithCache","segmentMethod","$2e9bc5022d60fc00$var$strokePathDirect","$2e9bc5022d60fc00$export$55e463fa7bcd3469","_points","_segments","_pointsUpdated","_interpolate","$2e9bc5022d60fc00$var$_getInterpolationMethod","interpolated","pathSegment","$2e9bc5022d60fc00$var$inRange$1","hitRadius","$2e9bc5022d60fc00$export$bd159b522b230b7a","mouseX","mouseY","inXRange","inYRange","hoverRadius","$2e9bc5022d60fc00$var$getBarBounds","bar","half","$2e9bc5022d60fc00$var$skipOrLimit","skip1","$2e9bc5022d60fc00$var$boundingRects","maxW","maxH","skip2","$2e9bc5022d60fc00$var$parseBorderWidth","maxR","skip3","enableBorder","$2e9bc5022d60fc00$var$parseBorderRadius","outer","$2e9bc5022d60fc00$var$inRange","skipX","skipY","$2e9bc5022d60fc00$var$addNormalRectPath","$2e9bc5022d60fc00$var$inflateRect","refRect","$2e9bc5022d60fc00$export$a16ed71bf4b07672","addRectPath","$2e9bc5022d60fc00$export$7a5d735b2ab6389d","ArcElement","LineElement","PointElement","BarElement","$2e9bc5022d60fc00$var$cleanDecimatedDataset","$2e9bc5022d60fc00$var$cleanDecimatedData","$2e9bc5022d60fc00$export$be17f937e9aa7533","algorithm","beforeElementsUpdate","xAxis","$2e9bc5022d60fc00$var$getStartAndCountOfVisiblePointsSimplified","threshold","decimated","samples","bucketWidth","sampledIndex","endIndex","maxAreaPoint","maxArea","nextA","avgY","avgRangeStart","avgRangeEnd","avgRangeLength","rangeOffs","rangeTo","pointAx","pointAy","$2e9bc5022d60fc00$var$lttbDecimation","minIndex","maxIndex","startIndex","xMin","dx","lastIndex","intermediateIndex1","intermediateIndex2","$2e9bc5022d60fc00$var$minMaxDecimation","$2e9bc5022d60fc00$var$_getBounds","$2e9bc5022d60fc00$var$_findSegmentEnd","$2e9bc5022d60fc00$var$_getEdge","$2e9bc5022d60fc00$var$_createBoundaryLine","boundary","linePoints","$2e9bc5022d60fc00$var$_pointsFromSegments","$2e9bc5022d60fc00$var$_resolveTarget","index57","propagate","fill1","visited","$2e9bc5022d60fc00$var$_decodeFill","index58","fill2","fillOption","fill5","$2e9bc5022d60fc00$var$parseFillOption","firstCh","index59","$2e9bc5022d60fc00$var$decodeTargetIndex","$2e9bc5022d60fc00$var$addPointsBelow","sourcePoint","linesBelow","postponed","$2e9bc5022d60fc00$var$findPoint","unshift","pointValue","firstValue","lastValue","$2e9bc5022d60fc00$var$simpleArc","$2e9bc5022d60fc00$var$_getTarget","fill6","index62","$2e9bc5022d60fc00$var$getLineByIndex","index60","sourcePoints","index61","below","$2e9bc5022d60fc00$var$getLinesBelow","$2e9bc5022d60fc00$var$_buildStackLine","fill8","fill4","$2e9bc5022d60fc00$var$_getTargetValue","$2e9bc5022d60fc00$var$computeCircularBoundary","fill7","fill3","$2e9bc5022d60fc00$var$_getTargetPixel","$2e9bc5022d60fc00$var$computeLinearBoundary","$2e9bc5022d60fc00$var$computeBoundary","$2e9bc5022d60fc00$var$_drawfill","lineOpts","above","$2e9bc5022d60fc00$var$clipVertical","$2e9bc5022d60fc00$var$fill","$2e9bc5022d60fc00$var$doFill","clipY","lineLoop","color3","tpoints","targetSegments","tgt","subBounds","fillSources","fillSource","$2e9bc5022d60fc00$var$_segments","src","notShape","$2e9bc5022d60fc00$var$clipBounds","$2e9bc5022d60fc00$var$interpolatedLineTo","targetLoop","interpolatedPoint","$2e9bc5022d60fc00$export$d19ba4d812bed757","afterDatasetsUpdate","_args","$filler","beforeDraw","draw2","drawTime","beforeDatasetsDraw","beforeDatasetDraw","$2e9bc5022d60fc00$var$getBoxSize","labelOpts","boxHeight","boxWidth","usePointStyle","itemHeight","$2e9bc5022d60fc00$var$Legend","_added","legendHitBoxes","_hoveredItem","doughnutMode","legendItems","columnSizes","lineWidths","buildLabels","labelFont","_computeTitleHeight","_fitRows","_fitCols","hitboxes","totalHeight","row","heightLimit","totalWidth","currentColWidth","currentColHeight","col","adjustHitBoxes","rtlHelper","hitbox","_draw","defaultColor","fontColor","halfFontSize","cursor","textDirection","lineDash","drawOptions","SQRT2","yBoxTop","xBoxLeft","drawLegendBox","titleFont","titlePadding","topPaddingPlusHalfFontSize","_getLegendItemAt","hitBox","lh","handleEvent","onLeave","$2e9bc5022d60fc00$var$isListened","hoveredItem","sameItem","$2e9bc5022d60fc00$export$ed247974535929c7","_element","afterEvent","index63","ci","color4","$2e9bc5022d60fc00$var$Title","_padding","textSize","_drawArgs","fontOpts","$2e9bc5022d60fc00$export$f99233281efd08a0","titleBlock","$2e9bc5022d60fc00$var$createTitle","$2e9bc5022d60fc00$var$map","WeakMap","$2e9bc5022d60fc00$export$d5c56664638992a4","$2e9bc5022d60fc00$var$positioners","average","eventPosition","nearestElement","tp","$2e9bc5022d60fc00$var$pushOrConcat","toPush","$2e9bc5022d60fc00$var$splitNewlines","String","$2e9bc5022d60fc00$var$createTooltipItem","index64","$2e9bc5022d60fc00$var$getTooltipSize","body","footer","bodyFont","footerFont","titleLineCount","footerLineCount","bodyLineItemCount","combinedBodyLength","bodyItem","before","after","beforeBody","afterBody","titleSpacing","titleMarginBottom","displayColors","bodySpacing","footerMarginTop","footerSpacing","widthPadding","maxLineWidth","$2e9bc5022d60fc00$var$determineXAlign","yAlign","chartWidth","xAlign","caret","caretSize","caretPadding","$2e9bc5022d60fc00$var$doesNotFitWithAlign","$2e9bc5022d60fc00$var$determineAlignment","$2e9bc5022d60fc00$var$determineYAlign","$2e9bc5022d60fc00$var$getBackgroundPoint","alignment","paddingAndSize","$2e9bc5022d60fc00$var$alignX","$2e9bc5022d60fc00$var$alignY","$2e9bc5022d60fc00$var$getAlignedX","$2e9bc5022d60fc00$var$getBeforeAfterBodyLines","$2e9bc5022d60fc00$var$overrideCallbacks","$2e9bc5022d60fc00$var$Tooltip","opacity","_eventPosition","_size","_cachedAnimations","_tooltipItems","dataPoints","caretX","caretY","labelColors","labelPointStyles","labelTextColors","tooltipItems","getTitle","beforeTitle","afterTitle","getBeforeBody","getBody","bodyItems","scoped","beforeLabel","afterLabel","getAfterBody","getFooter","beforeFooter","afterFooter","_createItems","index65","itemSort","labelColor","labelPointStyle","labelTextColor","positionAndSize","backgroundPoint","external","drawCaret","tooltipPoint","caretPosition","getCaretPosition","x3","y3","ptX","ptY","titleAlign","titleColor","_drawColorBox","colorX","rtlColorX","yOffSet","colorY","multiKeyBackground","outerX","innerX","strokeRect","drawBody","bodyAlign","bodyLineHeight","xLinePadding","fillLineOfText","bodyAlignForCalculation","textColor","bodyColor","drawFooter","footerAlign","footerColor","tooltipSize","quadraticCurveTo","_updateAnimationTarget","animX","animY","_willRender","hasTooltipContent","globalAlpha","index66","positionChanged","_positionChanged","_ignoreReplayEvents","positioners","$2e9bc5022d60fc00$export$28c660c63b792dea","afterInit","afterDraw","labelCount","$2e9bc5022d60fc00$export$8b3ca321c77fdea6","Decimation","Filler","Legend","SubTitle","Title","Tooltip","$2e9bc5022d60fc00$var$findOrAddLabel","index68","addedLabels","index67","$2e9bc5022d60fc00$var$addIfString","lastIndexOf","$2e9bc5022d60fc00$export$29e663ba4d09fe7","_startValue","_valueRange","_addedLabels","added","index70","index71","index69","index72","$2e9bc5022d60fc00$var$generateTicks$1","generationOptions","dataRange","precision","maxTicks","maxDigits","includeBounds","maxSpaces","rmin","rmax","countDefined","minSpacing","niceMin","niceMax","numSpaces","decimalPlaces","$2e9bc5022d60fc00$var$relativeLabelSize","$2e9bc5022d60fc00$var$LinearScaleBase","_endValue","handleTickRangeOptions","setMin","setMax","minSign","maxSign","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","getTickLimit","stepSize","computeTickLimit","$2e9bc5022d60fc00$export$e7f4e5e8656f0b93","$2e9bc5022d60fc00$var$isMajor","tickVal","$2e9bc5022d60fc00$export$85295eaf7cb3ac3e","index73","_zero","exp","endExp","endSignificand","significand","lastTick","$2e9bc5022d60fc00$var$generateTicks","$2e9bc5022d60fc00$var$getTickBackdropHeight","$2e9bc5022d60fc00$var$determineLimits","$2e9bc5022d60fc00$var$fitWithPointLabels","limits","valueCount","_pointLabels","pointLabelOpts","additionalAngle","centerPointLabels","getPointLabelContext","getPointPosition","drawingArea","plFont","$2e9bc5022d60fc00$var$updateLimits","setCenterPoint","_pointLabelItems","extra","outerDistance","pointLabelPosition","$2e9bc5022d60fc00$var$yForAngle","$2e9bc5022d60fc00$var$getTextAlignForAngle","$2e9bc5022d60fc00$var$leftForTextAlign","$2e9bc5022d60fc00$var$buildPointLabelItems","hLimits","vLimits","$2e9bc5022d60fc00$var$pathRadiusLine","$2e9bc5022d60fc00$export$cfafc36d95386d38","index75","leftMovement","rightMovement","topMovement","bottomMovement","index76","scalingFactor","getValueForDistanceFromCenter","scaledDistance","index77","pointLabel","index78","distanceFromCenter","index79","getBasePosition","index80","getPointLabelPosition","index81","backdropLeft","backdropTop","backdropWidth","backdropHeight","$2e9bc5022d60fc00$var$drawPointLabels","index82","gridLineOpts","color5","$2e9bc5022d60fc00$var$drawRadiusLine","color6","index83","animate","$2e9bc5022d60fc00$var$INTERVALS","millisecond","common","steps","second","minute","hour","day","week","month","quarter","year","$2e9bc5022d60fc00$var$UNITS","$2e9bc5022d60fc00$var$sorter","$2e9bc5022d60fc00$var$parse","adapter","_adapter","parser","isoWeekday","_parseOpts","$2e9bc5022d60fc00$var$determineUnitForAutoTicks","minUnit","capacity","interval","$2e9bc5022d60fc00$var$addTick","time","timestamps","$2e9bc5022d60fc00$var$ticksFromTimestamps","majorUnit","map2","map1","index84","$2e9bc5022d60fc00$var$setMajorTicks","$2e9bc5022d60fc00$export$a894c72689ff3ec","_unit","_majorUnit","_offsets","_normalized","adapters","displayFormats","normalized","_applyBounds","_getLabelBounds","getLabelTimestamps","timeOpts","_generate","_getLabelCapacity","$2e9bc5022d60fc00$var$determineUnitForFormatting","$2e9bc5022d60fc00$var$determineMajorUnit","initOffsets","offsetAfterAutoskip","getDecimalForValue","hasWeekday","getDataTimestamps","tooltipFormat","datetime","_tickFormatFunction","index85","minorFormat","majorFormat","offsets","_getLabelSize","ticksOpts","tickLabelWidth","cosRotation","sinRotation","tickFontSize","exampleTime","exampleLabel","$2e9bc5022d60fc00$var$interpolate","prevSource","nextSource","prevTarget","nextTarget","span","$2e9bc5022d60fc00$export$85df64a8eb6dc986","_table","_minPos","_tableRange","_getTimestampsForTable","buildLookupTable","CategoryScale","LinearScale","LogarithmicScale","RadialLinearScale","TimeScale","TimeSeriesScale","$cf422c3a51eae3ca$export$2e2bcd8739ae039","$4049e6bf31df43d6$var$clickHooks","$4049e6bf31df43d6$var$moveHooks","$4049e6bf31df43d6$var$hooks","$4049e6bf31df43d6$var$handleEvent","state","listened","moveListened","$4049e6bf31df43d6$var$getNearestItem","hovered","$4049e6bf31df43d6$var$dispatchEvent","leave","enter","$4049e6bf31df43d6$var$dispatchMoveEvents","$4049e6bf31df43d6$var$handleMoveEvents","elOpts","dblclick","click","clickTimeout","dblClickSpeed","$4049e6bf31df43d6$var$handleClickEvents","nearestItems","_index","$4049e6bf31df43d6$var$adjustScaleRange","annotations","scaleIDOption","annotation4","$4049e6bf31df43d6$var$updateLimits","$4049e6bf31df43d6$var$getScaleLimits","$4049e6bf31df43d6$var$changeScaleLimit","suggestedLimit","$4049e6bf31df43d6$var$scaleLimitDefined","$4049e6bf31df43d6$var$verifyScaleIDs","annotation2","$4049e6bf31df43d6$var$verifyProperties","annotation3","annotation5","$4049e6bf31df43d6$var$clamp","$4049e6bf31df43d6$var$clampAll","$4049e6bf31df43d6$var$inBoxRange","hBorderWidth","$4049e6bf31df43d6$var$getElementCenterPoint","$4049e6bf31df43d6$var$isOlderPart","act","req","substr","$4049e6bf31df43d6$var$isPercentString","$4049e6bf31df43d6$var$toPercent","$4049e6bf31df43d6$var$getRelativePosition","positionOption","$4049e6bf31df43d6$var$getSize","$4049e6bf31df43d6$var$toPosition","$4049e6bf31df43d6$var$isBoundToPoint","xValue","yValue","$4049e6bf31df43d6$var$widthCache","$4049e6bf31df43d6$var$isImageOrCanvas","content","$4049e6bf31df43d6$var$translate","$4049e6bf31df43d6$var$setBorderStyle","$4049e6bf31df43d6$var$setShadowStyle","shadowColor","backgroundShadowColor","shadowBlur","shadowOffsetX","shadowOffsetY","$4049e6bf31df43d6$var$measureLabelSize","mapKey","_measureText","$4049e6bf31df43d6$var$drawBox","borderShadowColor","$4049e6bf31df43d6$var$drawLabel","$4049e6bf31df43d6$var$calculateTextAlignment","miterLimit","$4049e6bf31df43d6$var$setTextStrokeStyle","$4049e6bf31df43d6$var$getRectCenterPoint","$4049e6bf31df43d6$var$rotated","cx","cy","$4049e6bf31df43d6$var$scaleValue","$4049e6bf31df43d6$var$getChartDimensionByScale","$4049e6bf31df43d6$var$getChartPoint","xScaleID","yScaleID","$4049e6bf31df43d6$var$getChartRect","xDim","xMax","yDim","yMin","yMax","$4049e6bf31df43d6$var$resolvePointPosition","xAdjust","yAdjust","$4049e6bf31df43d6$var$getChartCircle","$4049e6bf31df43d6$var$BoxAnnotation","drawLabel","halfBorder","labelSize","labelRect","$4049e6bf31df43d6$var$calculateX","$4049e6bf31df43d6$var$calculateY","resolveElementProperties","adjust","$4049e6bf31df43d6$var$calculatePosition$1","boxOpts","padStart","padEnd","adjustScaleRange","$4049e6bf31df43d6$var$pointInLine","$4049e6bf31df43d6$var$interpolateX","$4049e6bf31df43d6$var$interpolateY","$4049e6bf31df43d6$var$sqr","$4049e6bf31df43d6$var$isLineInArea","$4049e6bf31df43d6$var$limitPointToArea","$4049e6bf31df43d6$var$LineAnnotation","intersects","dy","lenSq","xx","yy","labelIsVisible","isOnLabel","labelX","labelY","h2","startOpts","endOpts","startAdjust","endAdjust","arrowStartOpts","arrowHeads","arrowEndOpts","$4049e6bf31df43d6$var$getLineAdjust","$4049e6bf31df43d6$var$getArrowHeads","$4049e6bf31df43d6$var$drawArrowHead","labelTextSize","$4049e6bf31df43d6$var$limitLineToArea","lblPadding","xPadding","yPadding","tempPadding","$4049e6bf31df43d6$var$getPadding","sizes","$4049e6bf31df43d6$var$calculateAutoRotation","$4049e6bf31df43d6$var$rotatedSize","space","$4049e6bf31df43d6$var$spaceAround","$4049e6bf31df43d6$var$calculateTAdjust","$4049e6bf31df43d6$var$calculateT","xCoordinateSizes","yCoordinateSizes","$4049e6bf31df43d6$var$adjustLabelCoordinate","$4049e6bf31df43d6$var$calculateLabelPosition","$4049e6bf31df43d6$var$loadLabelRect","$4049e6bf31df43d6$var$arrowHeadsDefaults","lineSize","lineW","lineH","coordinate","halfSize","arrowOpts","arrowOffsetX","$4049e6bf31df43d6$var$EllipseAnnotation","ellipse","xRadius","yRadius","cosAngle","sinAngle","$4049e6bf31df43d6$var$pointInEllipse","$4049e6bf31df43d6$var$LabelAnnotation","pointX","pointY","calloutPosition","callout","separatorStart","separatorEnd","$4049e6bf31df43d6$var$getCalloutSeparatorAdjust","$4049e6bf31df43d6$var$getCalloutSeparatorCoord","sideStart","sideEnd","side","$4049e6bf31df43d6$var$getCalloutSideAdjust","$4049e6bf31df43d6$var$getCalloutSideCoord","rotatedPoint","$4049e6bf31df43d6$var$drawCallout","boxSize","$4049e6bf31df43d6$var$calculatePosition","$4049e6bf31df43d6$var$measureRect","xPoints","yPoints","$4049e6bf31df43d6$var$positions","$4049e6bf31df43d6$var$resolveCalloutAutoPosition","$4049e6bf31df43d6$var$resolveCalloutPosition","$4049e6bf31df43d6$var$PointAnnotation","$4049e6bf31df43d6$var$inPointRange","$4049e6bf31df43d6$var$PolygonAnnotation","isInside","bY","bX","$4049e6bf31df43d6$var$pointIsInPolygon","sides","optionScope","initProperties","$4049e6bf31df43d6$var$annotationTypes","polygon","$4049e6bf31df43d6$var$directUpdater","$4049e6bf31df43d6$var$resolveType","$4049e6bf31df43d6$var$updateElements","animOpts","$4049e6bf31df43d6$var$resolveAnimations","$4049e6bf31df43d6$var$resyncElements","annotationOptions","$4049e6bf31df43d6$var$getOrCreateElement","$4049e6bf31df43d6$var$getContext","$4049e6bf31df43d6$var$toSkip","$4049e6bf31df43d6$var$updateSubElements","$4049e6bf31df43d6$var$resolveAnnotationOptions","mainElement","subElements","definition","subElement","subResolver","elementClass","$4049e6bf31df43d6$var$resolveObj","defs","optDefs","annotation6","$4049e6bf31df43d6$var$chartStates","$4049e6bf31df43d6$var$draw","caller","visibleElements","$4049e6bf31df43d6$var$drawElements","$4049e6bf31df43d6$var$drawSubElements","$dad545c909cfec2d$var$newShade","hexColor","magnitude","decimalColor","afterRegister","pkg","ver","strict","$4049e6bf31df43d6$var$requireVersion","afterUnregister","beforeInit","annotation1","$4049e6bf31df43d6$var$verifyScaleOptions","$4049e6bf31df43d6$var$updateListeners","afterDatasetsDraw","beforeEvent","_getState","$dad545c909cfec2d$var$colors","$dad545c909cfec2d$var$indexToMin","$dad545c909cfec2d$var$indexToMax","graph","$parcel$interopDefault","avg","annotation","idx2","midLine"],"version":3,"file":"index.92b3d5d1.js.map"} \ No newline at end of file diff --git a/index.html b/index.html index 02ef79a6..2f9f141f 100644 --- a/index.html +++ b/index.html @@ -1 +1 @@ -Python Package Manager Shootout

Python Package Manager Shootout

Benchmarks of various operations for Python package managers. The benchmarks are generated from lincolnloop/python-package-manager-shootout.

The list of packages comes from Sentry's requirements.txt file which was chosen arbitrarily as a non-trivial real-world example. If you'd like to know about the methodology, more documentation and the actual benchmarking code is available in the repo.

For more information, see the project announcement.

Package Managers

The benchmarks run in GitHub Actions every six hours and this site displays an average of the last four runs.
All graphs show elapsed time in seconds, so lower = faster.

Install

This test measures the time to install all packages from a valid lock file. It is performed with both a cold package cache (no packages cached) and a warm package cache (all necessary packages are cached).

Lock

This test measures the time to generate a lock file from the list of packages.

Update

This test measures the time to update and install all dependencies in the lock file.

Add Package

This test measures the time to add a new package and regenerate the lock file.

Tooling

This test measures the time to install the tool itself using the recommended method from the documentation.

\ No newline at end of file +Python Package Manager Shootout

Python Package Manager Shootout

Benchmarks of various operations for Python package managers. The benchmarks are generated from lincolnloop/python-package-manager-shootout.

The list of packages comes from Sentry's requirements.txt file which was chosen arbitrarily as a non-trivial real-world example. If you'd like to know about the methodology, more documentation and the actual benchmarking code is available in the repo.

For more information, see the project announcement.

Package Managers

The benchmarks run in GitHub Actions every six hours and this site displays an average of the last four runs.
All graphs show elapsed time in seconds, so lower = faster.

Install

This test measures the time to install all packages from a valid lock file. It is performed with both a cold package cache (no packages cached) and a warm package cache (all necessary packages are cached).

Lock

This test measures the time to generate a lock file from the list of packages.

Update

This test measures the time to update and install all dependencies in the lock file.

Add Package

This test measures the time to add a new package and regenerate the lock file.

Tooling

This test measures the time to install the tool itself using the recommended method from the documentation.

\ No newline at end of file diff --git a/ogimage.png b/ogimage.png index 78b5c585adc514b37fbad7b4448d757c1bc06d4a..510416c4c059fc56b7a6e055162c0d4f2f825437 100644 GIT binary patch delta 13011 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 $sVvQu)#RmXnJUy^_<|eR3+|JWqg0+izoa_-h z5^{@lyTvn1xjxCf3$Yliy&p0`mZkk`Z|CBY{E`se`?!gnOnOtE!15rR@G|XSGqLT^ zH`V_&392WwtQXU@=&G*xPDe$I^5=`y@mo<#Gl@RGaLQWsW@Ap*rRShH>U4Je^wBb^ zHdrdgXR<%AYdNaCAq86JGvX7$ko!vhk-%~Zm%q{NI*znd3kt8kpTi3G^DU$vnondR zx0l3r4#|YORJViWVm{)(Hj!*o3HOcOk95T|E2VtvFYLDzpF=B+{rXiP?P5W%Z85YSmB?ub+Xw}PzCWsow)LkVV@9x{Ya&pc-`xkro9uhAzn);Yc{E9 zFORXiw$|Cy*vb&q&PqrXIQ$qP3 zJkH}WB)%s2+0KXn)kGxG_Kl(or79VIu2$<379otE*&qbXTbo5knjB_te1f7weRTd@ zBF{Ry7EkG8M|$HHvnzD#?V4C^{T(Qhuj3{uC4LtVAn)r*xL%!XdPW&iY#s|^91{d$ z=#EKvnWdd`29RwHY06-%QCQ18r#XIYNi#|g-7^O@T!?BaqF9HEW(Z2mw5~~LE21Mz zWgEdadrA}3=2FIR(CuRtj=TQ}6H&yM@oW=OqoS`CfgJ4Z`@Av@KKlIq`}_AYQO3*HgFn;RN{O#SS1W=U+1oleaOH&mOohS#Vwx$CkQ`f zXtlV9rtF_BzV6P|NsN5?LFhKZH^ogkhvmI+;m~6%?Ew!noT);`+_4o$*eI`ah5}b; zH4>Z4<09VKp}$kN1*$qh>wYNU7^rFbmst0^8wmtw(~%#oUVJ|o-02Vh#`(O*g1RS% z_;Tb(64V>3Gn__f7ZU{pp}U=UUKwd=E(7_SH^~%%mw&)Ss+u|(;k~!tu=jmOwpk>I zN?58pl;jX}znPexW~+UL_)6nzdEesQT{FE;Yel$g8ysc&NQw5|P=wFmkzoUFey#3x zJgLKQ^cKML2iWc>;#CIFp2llA|=9K Gy#5>KPA+u- delta 12989 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