From 40b2d1928e10fc23131517d642df9000bed0667b Mon Sep 17 00:00:00 2001 From: a123dat57 Date: Mon, 29 Sep 2025 14:29:19 +0200 Subject: [PATCH 1/4] Update chart.js --- www/ftui/modules/chart.js/chart.js | 25719 +++++++++++++-------------- 1 file changed, 12772 insertions(+), 12947 deletions(-) diff --git a/www/ftui/modules/chart.js/chart.js b/www/ftui/modules/chart.js/chart.js index fc119253..9ea0b0a6 100755 --- a/www/ftui/modules/chart.js/chart.js +++ b/www/ftui/modules/chart.js/chart.js @@ -1,8631 +1,8439 @@ /*! - * Chart.js v3.0.0-beta + * Chart.js v3.9.1 * https://www.chartjs.org - * (c) 2020 Chart.js Contributors + * (c) 2022 Chart.js Contributors * Released under the MIT License */ -const Chart = (function () { - function _defineProperties(target, props) { - for (let i = 0; i < props.length; i++) { - const descriptor = props[i]; - descriptor.enumerable = descriptor.enumerable || false; - descriptor.configurable = true; - if ('value' in descriptor) descriptor.writable = true; - Object.defineProperty(target, descriptor.key, descriptor); - } - } +(function (global, factory) { +typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : +typeof define === 'function' && define.amd ? define(factory) : +(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Chart = factory()); +})(this, (function () { 'use strict'; - function _createClass(Constructor, protoProps, staticProps) { - if (protoProps) _defineProperties(Constructor.prototype, protoProps); - if (staticProps) _defineProperties(Constructor, staticProps); - return Constructor; +function noop() {} +const uid = (function() { + let id = 0; + return function() { + return id++; + }; +}()); +function isNullOrUndef(value) { + return value === null || typeof value === 'undefined'; +} +function isArray(value) { + if (Array.isArray && Array.isArray(value)) { + return true; } - - function _extends() { - _extends = Object.assign || function (target) { - for (let i = 1; i < arguments.length; i++) { - const source = arguments[i]; - - for (const key in source) { - if (Object.prototype.hasOwnProperty.call(source, key)) { - target[key] = source[key]; - } - } + const type = Object.prototype.toString.call(value); + if (type.slice(0, 7) === '[object' && type.slice(-6) === 'Array]') { + return true; + } + return false; +} +function isObject(value) { + return value !== null && Object.prototype.toString.call(value) === '[object Object]'; +} +const isNumberFinite = (value) => (typeof value === 'number' || value instanceof Number) && isFinite(+value); +function finiteOrDefault(value, defaultValue) { + return isNumberFinite(value) ? value : defaultValue; +} +function valueOrDefault(value, defaultValue) { + return typeof value === 'undefined' ? defaultValue : value; +} +const toPercentage = (value, dimension) => + typeof value === 'string' && value.endsWith('%') ? + parseFloat(value) / 100 + : value / dimension; +const toDimension = (value, dimension) => + typeof value === 'string' && value.endsWith('%') ? + parseFloat(value) / 100 * dimension + : +value; +function callback(fn, args, thisArg) { + if (fn && typeof fn.call === 'function') { + return fn.apply(thisArg, args); + } +} +function each(loopable, fn, thisArg, reverse) { + let i, len, keys; + if (isArray(loopable)) { + len = loopable.length; + if (reverse) { + for (i = len - 1; i >= 0; i--) { + fn.call(thisArg, loopable[i], i); } - - return target; - }; - - return _extends.apply(this, arguments); + } else { + for (i = 0; i < len; i++) { + fn.call(thisArg, loopable[i], i); + } + } + } else if (isObject(loopable)) { + keys = Object.keys(loopable); + len = keys.length; + for (i = 0; i < len; i++) { + fn.call(thisArg, loopable[keys[i]], keys[i]); + } } - - function _inheritsLoose(subClass, superClass) { - subClass.prototype = Object.create(superClass.prototype); - subClass.prototype.constructor = subClass; - subClass.__proto__ = superClass; +} +function _elementsEqual(a0, a1) { + let i, ilen, v0, v1; + if (!a0 || !a1 || a0.length !== a1.length) { + return false; } - - function _objectWithoutPropertiesLoose(source, excluded) { - if (source == null) return {}; - const target = {}; - const sourceKeys = Object.keys(source); - let key, i; - - for (i = 0; i < sourceKeys.length; i++) { - key = sourceKeys[i]; - if (excluded.indexOf(key) >= 0) continue; - target[key] = source[key]; + for (i = 0, ilen = a0.length; i < ilen; ++i) { + v0 = a0[i]; + v1 = a1[i]; + if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) { + return false; } - - return target; } - - function _assertThisInitialized(self) { - if (self === void 0) { - throw new ReferenceError('this hasn\'t been initialised - super() hasn\'t been called'); + return true; +} +function clone$1(source) { + if (isArray(source)) { + return source.map(clone$1); + } + if (isObject(source)) { + const target = Object.create(null); + const keys = Object.keys(source); + const klen = keys.length; + let k = 0; + for (; k < klen; ++k) { + target[keys[k]] = clone$1(source[keys[k]]); } - - return self; + return target; } - - function fontString(pixelSize, fontStyle, fontFamily) { - return fontStyle + ' ' + pixelSize + 'px ' + fontFamily; + return source; +} +function isValidKey(key) { + return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1; +} +function _merger(key, target, source, options) { + if (!isValidKey(key)) { + return; + } + const tval = target[key]; + const sval = source[key]; + if (isObject(tval) && isObject(sval)) { + merge(tval, sval, options); + } else { + target[key] = clone$1(sval); + } +} +function merge(target, source, options) { + const sources = isArray(source) ? source : [source]; + const ilen = sources.length; + if (!isObject(target)) { + return target; } - const requestAnimFrame = function () { - if (typeof window === 'undefined') { - return function (callback) { - return callback(); - }; - } - return window.requestAnimationFrame; - }(); - function throttled(fn, thisArg, updateFn) { - const updateArgs = updateFn || function (args) { - return Array.prototype.slice.call(args); - }; - let ticking = false; - let args = []; - return function () { - for (var _len = arguments.length, rest = new Array(_len), _key = 0; _key < _len; _key++) { - rest[_key] = arguments[_key]; - } - args = updateArgs(rest); - if (!ticking) { - ticking = true; - requestAnimFrame.call(window, function () { - ticking = false; - fn.apply(thisArg, args); - }); + options = options || {}; + const merger = options.merger || _merger; + for (let i = 0; i < ilen; ++i) { + source = sources[i]; + if (!isObject(source)) { + continue; + } + const keys = Object.keys(source); + for (let k = 0, klen = keys.length; k < klen; ++k) { + merger(keys[k], target, source, options); + } + } + return target; +} +function mergeIf(target, source) { + return merge(target, source, {merger: _mergerIf}); +} +function _mergerIf(key, target, source) { + if (!isValidKey(key)) { + return; + } + const tval = target[key]; + const sval = source[key]; + if (isObject(tval) && isObject(sval)) { + mergeIf(tval, sval); + } else if (!Object.prototype.hasOwnProperty.call(target, key)) { + target[key] = clone$1(sval); + } +} +function _deprecated(scope, value, previous, current) { + if (value !== undefined) { + console.warn(scope + ': "' + previous + + '" is deprecated. Please use "' + current + '" instead'); + } +} +const keyResolvers = { + '': v => v, + x: o => o.x, + y: o => o.y +}; +function resolveObjectKey(obj, key) { + const resolver = keyResolvers[key] || (keyResolvers[key] = _getKeyResolver(key)); + return resolver(obj); +} +function _getKeyResolver(key) { + const keys = _splitKey(key); + return obj => { + for (const k of keys) { + if (k === '') { + break; } - }; - } - - function drawFPS(chart, count, date, lastDate) { - const fps = 1000 / (date - lastDate) | 0; - const ctx = chart.ctx; - ctx.save(); - ctx.clearRect(0, 0, 50, 24); - ctx.fillStyle = 'black'; - ctx.textAlign = 'right'; - if (count) { - ctx.fillText(count, 50, 8); - ctx.fillText(fps + ' fps', 50, 18); + obj = obj && obj[k]; } - ctx.restore(); + return obj; + }; +} +function _splitKey(key) { + const parts = key.split('.'); + const keys = []; + let tmp = ''; + for (const part of parts) { + tmp += part; + if (tmp.endsWith('\\')) { + tmp = tmp.slice(0, -1) + '.'; + } else { + keys.push(tmp); + tmp = ''; + } + } + return keys; +} +function _capitalize(str) { + return str.charAt(0).toUpperCase() + str.slice(1); +} +const defined = (value) => typeof value !== 'undefined'; +const isFunction = (value) => typeof value === 'function'; +const setsEqual = (a, b) => { + if (a.size !== b.size) { + return false; } - const Animator = function () { - function Animator() { - this._request = null; - this._charts = new Map(); - this._running = false; - this._lastDate = undefined; - } - const _proto = Animator.prototype; - _proto._notify = function _notify(chart, anims, date, type) { - const callbacks = anims.listeners[type] || []; - const numSteps = anims.duration; - callbacks.forEach(function (fn) { - return fn({ - chart: chart, - numSteps: numSteps, - currentStep: Math.min(date - anims.start, numSteps) - }); - }); + for (const item of a) { + if (!b.has(item)) { + return false; } - ; - _proto._refresh = function _refresh() { - const me = this; - if (me._request) { - return; - } - me._running = true; - me._request = requestAnimFrame.call(window, function () { - me._update(); - me._request = null; - if (me._running) { - me._refresh(); - } - }); + } + return true; +}; +function _isClickEvent(e) { + return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu'; +} + +const PI = Math.PI; +const TAU = 2 * PI; +const PITAU = TAU + PI; +const INFINITY = Number.POSITIVE_INFINITY; +const RAD_PER_DEG = PI / 180; +const HALF_PI = PI / 2; +const QUARTER_PI = PI / 4; +const TWO_THIRDS_PI = PI * 2 / 3; +const log10 = Math.log10; +const sign = Math.sign; +function niceNum(range) { + const roundedRange = Math.round(range); + range = almostEquals(range, roundedRange, range / 1000) ? roundedRange : range; + const niceRange = Math.pow(10, Math.floor(log10(range))); + const fraction = range / niceRange; + const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10; + return niceFraction * niceRange; +} +function _factorize(value) { + const result = []; + const sqrt = Math.sqrt(value); + let i; + for (i = 1; i < sqrt; i++) { + if (value % i === 0) { + result.push(i); + result.push(value / i); + } + } + if (sqrt === (sqrt | 0)) { + result.push(sqrt); + } + result.sort((a, b) => a - b).pop(); + return result; +} +function isNumber(n) { + return !isNaN(parseFloat(n)) && isFinite(n); +} +function almostEquals(x, y, epsilon) { + return Math.abs(x - y) < epsilon; +} +function almostWhole(x, epsilon) { + const rounded = Math.round(x); + return ((rounded - epsilon) <= x) && ((rounded + epsilon) >= x); +} +function _setMinAndMaxByKey(array, target, property) { + let i, ilen, value; + for (i = 0, ilen = array.length; i < ilen; i++) { + value = array[i][property]; + if (!isNaN(value)) { + target.min = Math.min(target.min, value); + target.max = Math.max(target.max, value); + } + } +} +function toRadians(degrees) { + return degrees * (PI / 180); +} +function toDegrees(radians) { + return radians * (180 / PI); +} +function _decimalPlaces(x) { + if (!isNumberFinite(x)) { + return; + } + let e = 1; + let p = 0; + while (Math.round(x * e) / e !== x) { + e *= 10; + p++; + } + return p; +} +function getAngleFromPoint(centrePoint, anglePoint) { + const distanceFromXCenter = anglePoint.x - centrePoint.x; + const distanceFromYCenter = anglePoint.y - centrePoint.y; + const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter); + let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter); + if (angle < (-0.5 * PI)) { + angle += TAU; + } + return { + angle, + distance: radialDistanceFromCenter + }; +} +function distanceBetweenPoints(pt1, pt2) { + return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2)); +} +function _angleDiff(a, b) { + return (a - b + PITAU) % TAU - PI; +} +function _normalizeAngle(a) { + return (a % TAU + TAU) % TAU; +} +function _angleBetween(angle, start, end, sameAngleIsFullCircle) { + const a = _normalizeAngle(angle); + const s = _normalizeAngle(start); + const e = _normalizeAngle(end); + const angleToStart = _normalizeAngle(s - a); + const angleToEnd = _normalizeAngle(e - a); + const startToAngle = _normalizeAngle(a - s); + const endToAngle = _normalizeAngle(a - e); + return a === s || a === e || (sameAngleIsFullCircle && s === e) + || (angleToStart > angleToEnd && startToAngle < endToAngle); +} +function _limitValue(value, min, max) { + return Math.max(min, Math.min(max, value)); +} +function _int16Range(value) { + return _limitValue(value, -32768, 32767); +} +function _isBetween(value, start, end, epsilon = 1e-6) { + return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon; +} + +function _lookup(table, value, cmp) { + cmp = cmp || ((index) => table[index] < value); + let hi = table.length - 1; + let lo = 0; + let mid; + while (hi - lo > 1) { + mid = (lo + hi) >> 1; + if (cmp(mid)) { + lo = mid; + } else { + hi = mid; + } + } + return {lo, hi}; +} +const _lookupByKey = (table, key, value, last) => + _lookup(table, value, last + ? index => table[index][key] <= value + : index => table[index][key] < value); +const _rlookupByKey = (table, key, value) => + _lookup(table, value, index => table[index][key] >= value); +function _filterBetween(values, min, max) { + let start = 0; + let end = values.length; + while (start < end && values[start] < min) { + start++; + } + while (end > start && values[end - 1] > max) { + end--; + } + return start > 0 || end < values.length + ? values.slice(start, end) + : values; +} +const arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift']; +function listenArrayEvents(array, listener) { + if (array._chartjs) { + array._chartjs.listeners.push(listener); + return; + } + Object.defineProperty(array, '_chartjs', { + configurable: true, + enumerable: false, + value: { + listeners: [listener] } - ; - _proto._update = function _update() { - const me = this; - const date = Date.now(); - let remaining = 0; - me._charts.forEach(function (anims, chart) { - if (!anims.running || !anims.items.length) { - return; - } - const items = anims.items; - let i = items.length - 1; - let draw = false; - let item; - for (; i >= 0; --i) { - item = items[i]; - if (item._active) { - item.tick(date); - draw = true; - } else { - items[i] = items[items.length - 1]; - items.pop(); - } - } - if (draw) { - chart.draw(); - me._notify(chart, anims, date, 'progress'); - } - if (chart.options.animation.debug) { - drawFPS(chart, items.length, date, me._lastDate); - } - if (!items.length) { - anims.running = false; - me._notify(chart, anims, date, 'complete'); - } - remaining += items.length; - }); - me._lastDate = date; - if (remaining === 0) { - me._running = false; - } - } - ; - _proto._getAnims = function _getAnims(chart) { - const charts = this._charts; - let anims = charts.get(chart); - if (!anims) { - anims = { - running: false, - items: [], - listeners: { - complete: [], - progress: [] + }); + arrayEvents.forEach((key) => { + const method = '_onData' + _capitalize(key); + const base = array[key]; + Object.defineProperty(array, key, { + configurable: true, + enumerable: false, + value(...args) { + const res = base.apply(this, args); + array._chartjs.listeners.forEach((object) => { + if (typeof object[method] === 'function') { + object[method](...args); } - }; - charts.set(chart, anims); + }); + return res; } - return anims; - } - ; - _proto.listen = function listen(chart, event, cb) { - this._getAnims(chart).listeners[event].push(cb); + }); + }); +} +function unlistenArrayEvents(array, listener) { + const stub = array._chartjs; + if (!stub) { + return; + } + const listeners = stub.listeners; + const index = listeners.indexOf(listener); + if (index !== -1) { + listeners.splice(index, 1); + } + if (listeners.length > 0) { + return; + } + arrayEvents.forEach((key) => { + delete array[key]; + }); + delete array._chartjs; +} +function _arrayUnique(items) { + const set = new Set(); + let i, ilen; + for (i = 0, ilen = items.length; i < ilen; ++i) { + set.add(items[i]); + } + if (set.size === ilen) { + return items; + } + return Array.from(set); +} + +function fontString(pixelSize, fontStyle, fontFamily) { + return fontStyle + ' ' + pixelSize + 'px ' + fontFamily; +} +const requestAnimFrame = (function() { + if (typeof window === 'undefined') { + return function(callback) { + return callback(); + }; + } + return window.requestAnimationFrame; +}()); +function throttled(fn, thisArg, updateFn) { + const updateArgs = updateFn || ((args) => Array.prototype.slice.call(args)); + let ticking = false; + let args = []; + return function(...rest) { + args = updateArgs(rest); + if (!ticking) { + ticking = true; + requestAnimFrame.call(window, () => { + ticking = false; + fn.apply(thisArg, args); + }); } - ; - _proto.add = function add(chart, items) { - let _this$_getAnims$items; - if (!items || !items.length) { - return; - } - (_this$_getAnims$items = this._getAnims(chart).items).push.apply(_this$_getAnims$items, items); + }; +} +function debounce(fn, delay) { + let timeout; + return function(...args) { + if (delay) { + clearTimeout(timeout); + timeout = setTimeout(fn, delay, args); + } else { + fn.apply(this, args); } - ; - _proto.has = function has(chart) { - return this._getAnims(chart).items.length > 0; + return delay; + }; +} +const _toLeftRightCenter = (align) => align === 'start' ? 'left' : align === 'end' ? 'right' : 'center'; +const _alignStartEnd = (align, start, end) => align === 'start' ? start : align === 'end' ? end : (start + end) / 2; +const _textX = (align, left, right, rtl) => { + const check = rtl ? 'left' : 'right'; + return align === check ? right : align === 'center' ? (left + right) / 2 : left; +}; +function _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) { + const pointCount = points.length; + let start = 0; + let count = pointCount; + if (meta._sorted) { + const {iScale, _parsed} = meta; + const axis = iScale.axis; + const {min, max, minDefined, maxDefined} = iScale.getUserBounds(); + if (minDefined) { + start = _limitValue(Math.min( + _lookupByKey(_parsed, iScale.axis, min).lo, + animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo), + 0, pointCount - 1); + } + if (maxDefined) { + count = _limitValue(Math.max( + _lookupByKey(_parsed, iScale.axis, max, true).hi + 1, + animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max), true).hi + 1), + start, pointCount) - start; + } else { + count = pointCount - start; + } + } + return {start, count}; +} +function _scaleRangesChanged(meta) { + const {xScale, yScale, _scaleRanges} = meta; + const newRanges = { + xmin: xScale.min, + xmax: xScale.max, + ymin: yScale.min, + ymax: yScale.max + }; + if (!_scaleRanges) { + meta._scaleRanges = newRanges; + return true; + } + const changed = _scaleRanges.xmin !== xScale.min + || _scaleRanges.xmax !== xScale.max + || _scaleRanges.ymin !== yScale.min + || _scaleRanges.ymax !== yScale.max; + Object.assign(_scaleRanges, newRanges); + return changed; +} + +class Animator { + constructor() { + this._request = null; + this._charts = new Map(); + this._running = false; + this._lastDate = undefined; + } + _notify(chart, anims, date, type) { + const callbacks = anims.listeners[type]; + const numSteps = anims.duration; + callbacks.forEach(fn => fn({ + chart, + initial: anims.initial, + numSteps, + currentStep: Math.min(date - anims.start, numSteps) + })); + } + _refresh() { + if (this._request) { + return; } - ; - _proto.start = function start(chart) { - const anims = this._charts.get(chart); - if (!anims) { - return; - } - anims.running = true; - anims.start = Date.now(); - anims.duration = anims.items.reduce(function (acc, cur) { - return Math.max(acc, cur._duration); - }, 0); - this._refresh(); - }; - _proto.running = function running(chart) { - if (!this._running) { - return false; - } - const anims = this._charts.get(chart); - if (!anims || !anims.running || !anims.items.length) { - return false; + this._running = true; + this._request = requestAnimFrame.call(window, () => { + this._update(); + this._request = null; + if (this._running) { + this._refresh(); } - return true; - } - ; - _proto.stop = function stop(chart) { - const anims = this._charts.get(chart); - if (!anims || !anims.items.length) { + }); + } + _update(date = Date.now()) { + let remaining = 0; + this._charts.forEach((anims, chart) => { + if (!anims.running || !anims.items.length) { return; } const items = anims.items; let i = items.length - 1; + let draw = false; + let item; for (; i >= 0; --i) { - items[i].cancel(); + item = items[i]; + if (item._active) { + if (item._total > anims.duration) { + anims.duration = item._total; + } + item.tick(date); + draw = true; + } else { + items[i] = items[items.length - 1]; + items.pop(); + } } - anims.items = []; - this._notify(chart, anims, Date.now(), 'complete'); + if (draw) { + chart.draw(); + this._notify(chart, anims, date, 'progress'); + } + if (!items.length) { + anims.running = false; + this._notify(chart, anims, date, 'complete'); + anims.initial = false; + } + remaining += items.length; + }); + this._lastDate = date; + if (remaining === 0) { + this._running = false; } - ; - _proto.remove = function remove(chart) { - return this._charts.delete(chart); - }; - return Animator; - }(); - const animator = new Animator(); - - function noop() {} - const uid = function () { - let id = 0; - return function () { - return id++; - }; - }(); - function isNullOrUndef(value) { - return value === null || typeof value === 'undefined'; } - function isArray(value) { - if (Array.isArray && Array.isArray(value)) { - return true; - } - const type = Object.prototype.toString.call(value); - if (type.substr(0, 7) === '[object' && type.substr(-6) === 'Array]') { - return true; + _getAnims(chart) { + const charts = this._charts; + let anims = charts.get(chart); + if (!anims) { + anims = { + running: false, + initial: true, + items: [], + listeners: { + complete: [], + progress: [] + } + }; + charts.set(chart, anims); } - return false; + return anims; } - function isObject(value) { - return value !== null && Object.prototype.toString.call(value) === '[object Object]'; - } - const isNumberFinite = function isNumberFinite(value) { - return (typeof value === 'number' || value instanceof Number) && isFinite(+value); - }; - function valueOrDefault(value, defaultValue) { - return typeof value === 'undefined' ? defaultValue : value; + listen(chart, event, cb) { + this._getAnims(chart).listeners[event].push(cb); } - function callback(fn, args, thisArg) { - if (fn && typeof fn.call === 'function') { - return fn.apply(thisArg, args); + add(chart, items) { + if (!items || !items.length) { + return; } + this._getAnims(chart).items.push(...items); } - function each(loopable, fn, thisArg, reverse) { - let i, len, keys; - if (isArray(loopable)) { - len = loopable.length; - if (reverse) { - for (i = len - 1; i >= 0; i--) { - fn.call(thisArg, loopable[i], i); - } - } else { - for (i = 0; i < len; i++) { - fn.call(thisArg, loopable[i], i); - } - } - } else if (isObject(loopable)) { - keys = Object.keys(loopable); - len = keys.length; - for (i = 0; i < len; i++) { - fn.call(thisArg, loopable[keys[i]], keys[i]); - } + has(chart) { + return this._getAnims(chart).items.length > 0; + } + start(chart) { + const anims = this._charts.get(chart); + if (!anims) { + return; } + anims.running = true; + anims.start = Date.now(); + anims.duration = anims.items.reduce((acc, cur) => Math.max(acc, cur._duration), 0); + this._refresh(); } - function _elementsEqual(a0, a1) { - let i, ilen, v0, v1; - if (!a0 || !a1 || a0.length !== a1.length) { + running(chart) { + if (!this._running) { return false; } - for (i = 0, ilen = a0.length; i < ilen; ++i) { - v0 = a0[i]; - v1 = a1[i]; - if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) { - return false; - } + const anims = this._charts.get(chart); + if (!anims || !anims.running || !anims.items.length) { + return false; } return true; } - function clone(source) { - if (isArray(source)) { - return source.map(clone); - } - if (isObject(source)) { - const target = Object.create(null); - const keys = Object.keys(source); - const klen = keys.length; - let k = 0; - for (; k < klen; ++k) { - target[keys[k]] = clone(source[keys[k]]); - } - return target; - } - return source; - } - function isValidKey(key) { - return ['__proto__', 'prototype', 'constructor'].indexOf(key) === -1; - } - function _merger(key, target, source, options) { - if (!isValidKey(key)) { + stop(chart) { + const anims = this._charts.get(chart); + if (!anims || !anims.items.length) { return; } - const tval = target[key]; - const sval = source[key]; - if (isObject(tval) && isObject(sval)) { - merge(tval, sval, options); - } else { - target[key] = clone(sval); - } - } - function merge(target, source, options) { - const sources = isArray(source) ? source : [source]; - const ilen = sources.length; - if (!isObject(target)) { - return target; - } - options = options || {}; - const merger = options.merger || _merger; - for (let i = 0; i < ilen; ++i) { - source = sources[i]; - if (!isObject(source)) { - continue; - } - const keys = Object.keys(source); - for (let k = 0, klen = keys.length; k < klen; ++k) { - merger(keys[k], target, source, options); - } + const items = anims.items; + let i = items.length - 1; + for (; i >= 0; --i) { + items[i].cancel(); } - return target; + anims.items = []; + this._notify(chart, anims, Date.now(), 'complete'); } - function mergeIf(target, source) { - return merge(target, source, { - merger: _mergerIf - }); + remove(chart) { + return this._charts.delete(chart); } - function _mergerIf(key, target, source) { - if (!isValidKey(key)) { - return; - } - const tval = target[key]; - const sval = source[key]; - if (isObject(tval) && isObject(sval)) { - mergeIf(tval, sval); - } else if (!Object.prototype.hasOwnProperty.call(target, key)) { - target[key] = clone(sval); +} +var animator = new Animator(); + +/*! + * @kurkle/color v0.2.1 + * https://github.com/kurkle/color#readme + * (c) 2022 Jukka Kurkela + * Released under the MIT License + */ +function round(v) { + return v + 0.5 | 0; +} +const lim = (v, l, h) => Math.max(Math.min(v, h), l); +function p2b(v) { + return lim(round(v * 2.55), 0, 255); +} +function n2b(v) { + return lim(round(v * 255), 0, 255); +} +function b2n(v) { + return lim(round(v / 2.55) / 100, 0, 1); +} +function n2p(v) { + return lim(round(v * 100), 0, 100); +} +const map$1 = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15}; +const hex = [...'0123456789ABCDEF']; +const h1 = b => hex[b & 0xF]; +const h2 = b => hex[(b & 0xF0) >> 4] + hex[b & 0xF]; +const eq = b => ((b & 0xF0) >> 4) === (b & 0xF); +const isShort = v => eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a); +function hexParse(str) { + var len = str.length; + var ret; + if (str[0] === '#') { + if (len === 4 || len === 5) { + ret = { + r: 255 & map$1[str[1]] * 17, + g: 255 & map$1[str[2]] * 17, + b: 255 & map$1[str[3]] * 17, + a: len === 5 ? map$1[str[4]] * 17 : 255 + }; + } else if (len === 7 || len === 9) { + ret = { + r: map$1[str[1]] << 4 | map$1[str[2]], + g: map$1[str[3]] << 4 | map$1[str[4]], + b: map$1[str[5]] << 4 | map$1[str[6]], + a: len === 9 ? (map$1[str[7]] << 4 | map$1[str[8]]) : 255 + }; } } - function _deprecated(scope, value, previous, current) { - if (value !== undefined) { - console.warn(scope + ': "' + previous + '" is deprecated. Please use "' + current + '" instead'); + return ret; +} +const alpha = (a, f) => a < 255 ? f(a) : ''; +function hexString(v) { + var f = isShort(v) ? h1 : h2; + return v + ? '#' + f(v.r) + f(v.g) + f(v.b) + alpha(v.a, f) + : undefined; +} +const HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/; +function hsl2rgbn(h, s, l) { + const a = s * Math.min(l, 1 - l); + const f = (n, k = (n + h / 30) % 12) => l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1); + return [f(0), f(8), f(4)]; +} +function hsv2rgbn(h, s, v) { + const f = (n, k = (n + h / 60) % 6) => v - v * s * Math.max(Math.min(k, 4 - k, 1), 0); + return [f(5), f(3), f(1)]; +} +function hwb2rgbn(h, w, b) { + const rgb = hsl2rgbn(h, 1, 0.5); + let i; + if (w + b > 1) { + i = 1 / (w + b); + w *= i; + b *= i; + } + for (i = 0; i < 3; i++) { + rgb[i] *= 1 - w - b; + rgb[i] += w; + } + return rgb; +} +function hueValue(r, g, b, d, max) { + if (r === max) { + return ((g - b) / d) + (g < b ? 6 : 0); + } + if (g === max) { + return (b - r) / d + 2; + } + return (r - g) / d + 4; +} +function rgb2hsl(v) { + const range = 255; + const r = v.r / range; + const g = v.g / range; + const b = v.b / range; + const max = Math.max(r, g, b); + const min = Math.min(r, g, b); + const l = (max + min) / 2; + let h, s, d; + if (max !== min) { + d = max - min; + s = l > 0.5 ? d / (2 - max - min) : d / (max + min); + h = hueValue(r, g, b, d, max); + h = h * 60 + 0.5; + } + return [h | 0, s || 0, l]; +} +function calln(f, a, b, c) { + return ( + Array.isArray(a) + ? f(a[0], a[1], a[2]) + : f(a, b, c) + ).map(n2b); +} +function hsl2rgb(h, s, l) { + return calln(hsl2rgbn, h, s, l); +} +function hwb2rgb(h, w, b) { + return calln(hwb2rgbn, h, w, b); +} +function hsv2rgb(h, s, v) { + return calln(hsv2rgbn, h, s, v); +} +function hue(h) { + return (h % 360 + 360) % 360; +} +function hueParse(str) { + const m = HUE_RE.exec(str); + let a = 255; + let v; + if (!m) { + return; + } + if (m[5] !== v) { + a = m[6] ? p2b(+m[5]) : n2b(+m[5]); + } + const h = hue(+m[2]); + const p1 = +m[3] / 100; + const p2 = +m[4] / 100; + if (m[1] === 'hwb') { + v = hwb2rgb(h, p1, p2); + } else if (m[1] === 'hsv') { + v = hsv2rgb(h, p1, p2); + } else { + v = hsl2rgb(h, p1, p2); + } + return { + r: v[0], + g: v[1], + b: v[2], + a: a + }; +} +function rotate(v, deg) { + var h = rgb2hsl(v); + h[0] = hue(h[0] + deg); + h = hsl2rgb(h); + v.r = h[0]; + v.g = h[1]; + v.b = h[2]; +} +function hslString(v) { + if (!v) { + return; + } + const a = rgb2hsl(v); + const h = a[0]; + const s = n2p(a[1]); + const l = n2p(a[2]); + return v.a < 255 + ? `hsla(${h}, ${s}%, ${l}%, ${b2n(v.a)})` + : `hsl(${h}, ${s}%, ${l}%)`; +} +const map$2 = { + x: 'dark', + Z: 'light', + Y: 're', + X: 'blu', + W: 'gr', + V: 'medium', + U: 'slate', + A: 'ee', + T: 'ol', + S: 'or', + B: 'ra', + C: 'lateg', + D: 'ights', + R: 'in', + Q: 'turquois', + E: 'hi', + P: 'ro', + O: 'al', + N: 'le', + M: 'de', + L: 'yello', + F: 'en', + K: 'ch', + G: 'arks', + H: 'ea', + I: 'ightg', + J: 'wh' +}; +const names$1 = { + OiceXe: 'f0f8ff', + antiquewEte: 'faebd7', + aqua: 'ffff', + aquamarRe: '7fffd4', + azuY: 'f0ffff', + beige: 'f5f5dc', + bisque: 'ffe4c4', + black: '0', + blanKedOmond: 'ffebcd', + Xe: 'ff', + XeviTet: '8a2be2', + bPwn: 'a52a2a', + burlywood: 'deb887', + caMtXe: '5f9ea0', + KartYuse: '7fff00', + KocTate: 'd2691e', + cSO: 'ff7f50', + cSnflowerXe: '6495ed', + cSnsilk: 'fff8dc', + crimson: 'dc143c', + cyan: 'ffff', + xXe: '8b', + xcyan: '8b8b', + xgTMnPd: 'b8860b', + xWay: 'a9a9a9', + xgYF: '6400', + xgYy: 'a9a9a9', + xkhaki: 'bdb76b', + xmagFta: '8b008b', + xTivegYF: '556b2f', + xSange: 'ff8c00', + xScEd: '9932cc', + xYd: '8b0000', + xsOmon: 'e9967a', + xsHgYF: '8fbc8f', + xUXe: '483d8b', + xUWay: '2f4f4f', + xUgYy: '2f4f4f', + xQe: 'ced1', + xviTet: '9400d3', + dAppRk: 'ff1493', + dApskyXe: 'bfff', + dimWay: '696969', + dimgYy: '696969', + dodgerXe: '1e90ff', + fiYbrick: 'b22222', + flSOwEte: 'fffaf0', + foYstWAn: '228b22', + fuKsia: 'ff00ff', + gaRsbSo: 'dcdcdc', + ghostwEte: 'f8f8ff', + gTd: 'ffd700', + gTMnPd: 'daa520', + Way: '808080', + gYF: '8000', + gYFLw: 'adff2f', + gYy: '808080', + honeyMw: 'f0fff0', + hotpRk: 'ff69b4', + RdianYd: 'cd5c5c', + Rdigo: '4b0082', + ivSy: 'fffff0', + khaki: 'f0e68c', + lavFMr: 'e6e6fa', + lavFMrXsh: 'fff0f5', + lawngYF: '7cfc00', + NmoncEffon: 'fffacd', + ZXe: 'add8e6', + ZcSO: 'f08080', + Zcyan: 'e0ffff', + ZgTMnPdLw: 'fafad2', + ZWay: 'd3d3d3', + ZgYF: '90ee90', + ZgYy: 'd3d3d3', + ZpRk: 'ffb6c1', + ZsOmon: 'ffa07a', + ZsHgYF: '20b2aa', + ZskyXe: '87cefa', + ZUWay: '778899', + ZUgYy: '778899', + ZstAlXe: 'b0c4de', + ZLw: 'ffffe0', + lime: 'ff00', + limegYF: '32cd32', + lRF: 'faf0e6', + magFta: 'ff00ff', + maPon: '800000', + VaquamarRe: '66cdaa', + VXe: 'cd', + VScEd: 'ba55d3', + VpurpN: '9370db', + VsHgYF: '3cb371', + VUXe: '7b68ee', + VsprRggYF: 'fa9a', + VQe: '48d1cc', + VviTetYd: 'c71585', + midnightXe: '191970', + mRtcYam: 'f5fffa', + mistyPse: 'ffe4e1', + moccasR: 'ffe4b5', + navajowEte: 'ffdead', + navy: '80', + Tdlace: 'fdf5e6', + Tive: '808000', + TivedBb: '6b8e23', + Sange: 'ffa500', + SangeYd: 'ff4500', + ScEd: 'da70d6', + pOegTMnPd: 'eee8aa', + pOegYF: '98fb98', + pOeQe: 'afeeee', + pOeviTetYd: 'db7093', + papayawEp: 'ffefd5', + pHKpuff: 'ffdab9', + peru: 'cd853f', + pRk: 'ffc0cb', + plum: 'dda0dd', + powMrXe: 'b0e0e6', + purpN: '800080', + YbeccapurpN: '663399', + Yd: 'ff0000', + Psybrown: 'bc8f8f', + PyOXe: '4169e1', + saddNbPwn: '8b4513', + sOmon: 'fa8072', + sandybPwn: 'f4a460', + sHgYF: '2e8b57', + sHshell: 'fff5ee', + siFna: 'a0522d', + silver: 'c0c0c0', + skyXe: '87ceeb', + UXe: '6a5acd', + UWay: '708090', + UgYy: '708090', + snow: 'fffafa', + sprRggYF: 'ff7f', + stAlXe: '4682b4', + tan: 'd2b48c', + teO: '8080', + tEstN: 'd8bfd8', + tomato: 'ff6347', + Qe: '40e0d0', + viTet: 'ee82ee', + JHt: 'f5deb3', + wEte: 'ffffff', + wEtesmoke: 'f5f5f5', + Lw: 'ffff00', + LwgYF: '9acd32' +}; +function unpack() { + const unpacked = {}; + const keys = Object.keys(names$1); + const tkeys = Object.keys(map$2); + let i, j, k, ok, nk; + for (i = 0; i < keys.length; i++) { + ok = nk = keys[i]; + for (j = 0; j < tkeys.length; j++) { + k = tkeys[j]; + nk = nk.replace(k, map$2[k]); + } + k = parseInt(names$1[ok], 16); + unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF]; + } + return unpacked; +} +let names; +function nameParse(str) { + if (!names) { + names = unpack(); + names.transparent = [0, 0, 0, 0]; + } + const a = names[str.toLowerCase()]; + return a && { + r: a[0], + g: a[1], + b: a[2], + a: a.length === 4 ? a[3] : 255 + }; +} +const RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/; +function rgbParse(str) { + const m = RGB_RE.exec(str); + let a = 255; + let r, g, b; + if (!m) { + return; + } + if (m[7] !== r) { + const v = +m[7]; + a = m[8] ? p2b(v) : lim(v * 255, 0, 255); + } + r = +m[1]; + g = +m[3]; + b = +m[5]; + r = 255 & (m[2] ? p2b(r) : lim(r, 0, 255)); + g = 255 & (m[4] ? p2b(g) : lim(g, 0, 255)); + b = 255 & (m[6] ? p2b(b) : lim(b, 0, 255)); + return { + r: r, + g: g, + b: b, + a: a + }; +} +function rgbString(v) { + return v && ( + v.a < 255 + ? `rgba(${v.r}, ${v.g}, ${v.b}, ${b2n(v.a)})` + : `rgb(${v.r}, ${v.g}, ${v.b})` + ); +} +const to = v => v <= 0.0031308 ? v * 12.92 : Math.pow(v, 1.0 / 2.4) * 1.055 - 0.055; +const from = v => v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); +function interpolate$1(rgb1, rgb2, t) { + const r = from(b2n(rgb1.r)); + const g = from(b2n(rgb1.g)); + const b = from(b2n(rgb1.b)); + return { + r: n2b(to(r + t * (from(b2n(rgb2.r)) - r))), + g: n2b(to(g + t * (from(b2n(rgb2.g)) - g))), + b: n2b(to(b + t * (from(b2n(rgb2.b)) - b))), + a: rgb1.a + t * (rgb2.a - rgb1.a) + }; +} +function modHSL(v, i, ratio) { + if (v) { + let tmp = rgb2hsl(v); + tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1)); + tmp = hsl2rgb(tmp); + v.r = tmp[0]; + v.g = tmp[1]; + v.b = tmp[2]; + } +} +function clone(v, proto) { + return v ? Object.assign(proto || {}, v) : v; +} +function fromObject(input) { + var v = {r: 0, g: 0, b: 0, a: 255}; + if (Array.isArray(input)) { + if (input.length >= 3) { + v = {r: input[0], g: input[1], b: input[2], a: 255}; + if (input.length > 3) { + v.a = n2b(input[3]); + } + } + } else { + v = clone(input, {r: 0, g: 0, b: 0, a: 1}); + v.a = n2b(v.a); + } + return v; +} +function functionParse(str) { + if (str.charAt(0) === 'r') { + return rgbParse(str); + } + return hueParse(str); +} +class Color { + constructor(input) { + if (input instanceof Color) { + return input; + } + const type = typeof input; + let v; + if (type === 'object') { + v = fromObject(input); + } else if (type === 'string') { + v = hexParse(input) || nameParse(input) || functionParse(input); } + this._rgb = v; + this._valid = !!v; } - function resolveObjectKey(obj, key) { - if (key.length < 3) { - return obj[key]; - } - const keys = key.split('.'); - for (let i = 0, n = keys.length; i < n; ++i) { - const k = keys[i]; - if (k in obj) { - obj = obj[k]; - } else { - return; - } - } - return obj; + get valid() { + return this._valid; } - function _capitalize(str) { - return str.charAt(0).toUpperCase() + str.slice(1); + get rgb() { + var v = clone(this._rgb); + if (v) { + v.a = b2n(v.a); + } + return v; } + set rgb(obj) { + this._rgb = fromObject(obj); + } + rgbString() { + return this._valid ? rgbString(this._rgb) : undefined; + } + hexString() { + return this._valid ? hexString(this._rgb) : undefined; + } + hslString() { + return this._valid ? hslString(this._rgb) : undefined; + } + mix(color, weight) { + if (color) { + const c1 = this.rgb; + const c2 = color.rgb; + let w2; + const p = weight === w2 ? 0.5 : weight; + const w = 2 * p - 1; + const a = c1.a - c2.a; + const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0; + w2 = 1 - w1; + c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5; + c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5; + c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5; + c1.a = p * c1.a + (1 - p) * c2.a; + this.rgb = c1; + } + return this; + } + interpolate(color, t) { + if (color) { + this._rgb = interpolate$1(this._rgb, color._rgb, t); + } + return this; + } + clone() { + return new Color(this.rgb); + } + alpha(a) { + this._rgb.a = n2b(a); + return this; + } + clearer(ratio) { + const rgb = this._rgb; + rgb.a *= 1 - ratio; + return this; + } + greyscale() { + const rgb = this._rgb; + const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11); + rgb.r = rgb.g = rgb.b = val; + return this; + } + opaquer(ratio) { + const rgb = this._rgb; + rgb.a *= 1 + ratio; + return this; + } + negate() { + const v = this._rgb; + v.r = 255 - v.r; + v.g = 255 - v.g; + v.b = 255 - v.b; + return this; + } + lighten(ratio) { + modHSL(this._rgb, 2, ratio); + return this; + } + darken(ratio) { + modHSL(this._rgb, 2, -ratio); + return this; + } + saturate(ratio) { + modHSL(this._rgb, 1, ratio); + return this; + } + desaturate(ratio) { + modHSL(this._rgb, 1, -ratio); + return this; + } + rotate(deg) { + rotate(this._rgb, deg); + return this; + } +} +function index_esm(input) { + return new Color(input); +} - function getScope(node, key) { - if (!key) { - return node; - } - const keys = key.split('.'); - for (let i = 0, n = keys.length; i < n; ++i) { - const k = keys[i]; - node = node[k] || (node[k] = Object.create(null)); - } +function isPatternOrGradient(value) { + if (value && typeof value === 'object') { + const type = value.toString(); + return type === '[object CanvasPattern]' || type === '[object CanvasGradient]'; + } + return false; +} +function color(value) { + return isPatternOrGradient(value) ? value : index_esm(value); +} +function getHoverColor(value) { + return isPatternOrGradient(value) + ? value + : index_esm(value).saturate(0.5).darken(0.1).hexString(); +} + +const overrides = Object.create(null); +const descriptors = Object.create(null); +function getScope$1(node, key) { + if (!key) { return node; } - const Defaults = function () { - function Defaults() { - this.color = 'rgba(0,0,0,0.1)'; - this.elements = {}; - this.events = ['mousemove', 'mouseout', 'click', 'touchstart', 'touchmove']; - this.font = { - color: '#666', - family: '\'Helvetica Neue\', \'Helvetica\', \'Arial\', sans-serif', - size: 12, - style: 'normal', - lineHeight: 1.2, - weight: null, - lineWidth: 0, - strokeStyle: undefined - }; - this.interaction = { - mode: 'nearest', - intersect: true - }; - this.hover = { - onHover: null - }; - this.maintainAspectRatio = true; - this.onHover = null; - this.onClick = null; - this.responsive = true; - this.showLine = true; - this.plugins = {}; - this.scale = undefined; - this.scales = {}; - this.controllers = {}; - } - const _proto = Defaults.prototype; - _proto.set = function set(scope, values) { - return merge(getScope(this, scope), values); - }; - _proto.get = function get(scope) { - return getScope(this, scope); - } - ; - _proto.route = function route(scope, name, targetScope, targetName) { - let _Object$definePropert; - const scopeObject = getScope(this, scope); - const targetScopeObject = getScope(this, targetScope); - const privateName = '_' + name; - Object.defineProperties(scopeObject, (_Object$definePropert = {}, _Object$definePropert[privateName] = { + const keys = key.split('.'); + for (let i = 0, n = keys.length; i < n; ++i) { + const k = keys[i]; + node = node[k] || (node[k] = Object.create(null)); + } + return node; +} +function set(root, scope, values) { + if (typeof scope === 'string') { + return merge(getScope$1(root, scope), values); + } + return merge(getScope$1(root, ''), scope); +} +class Defaults { + constructor(_descriptors) { + this.animation = undefined; + this.backgroundColor = 'rgba(0,0,0,0.1)'; + this.borderColor = 'rgba(0,0,0,0.1)'; + this.color = '#666'; + this.datasets = {}; + this.devicePixelRatio = (context) => context.chart.platform.getDevicePixelRatio(); + this.elements = {}; + this.events = [ + 'mousemove', + 'mouseout', + 'click', + 'touchstart', + 'touchmove' + ]; + this.font = { + family: "'Helvetica Neue', 'Helvetica', 'Arial', sans-serif", + size: 12, + style: 'normal', + lineHeight: 1.2, + weight: null + }; + this.hover = {}; + this.hoverBackgroundColor = (ctx, options) => getHoverColor(options.backgroundColor); + this.hoverBorderColor = (ctx, options) => getHoverColor(options.borderColor); + this.hoverColor = (ctx, options) => getHoverColor(options.color); + this.indexAxis = 'x'; + this.interaction = { + mode: 'nearest', + intersect: true, + includeInvisible: false + }; + this.maintainAspectRatio = true; + this.onHover = null; + this.onClick = null; + this.parsing = true; + this.plugins = {}; + this.responsive = true; + this.scale = undefined; + this.scales = {}; + this.showLine = true; + this.drawActiveElementsOnTop = true; + this.describe(_descriptors); + } + set(scope, values) { + return set(this, scope, values); + } + get(scope) { + return getScope$1(this, scope); + } + describe(scope, values) { + return set(descriptors, scope, values); + } + override(scope, values) { + return set(overrides, scope, values); + } + route(scope, name, targetScope, targetName) { + const scopeObject = getScope$1(this, scope); + const targetScopeObject = getScope$1(this, targetScope); + const privateName = '_' + name; + Object.defineProperties(scopeObject, { + [privateName]: { + value: scopeObject[name], writable: true - }, _Object$definePropert[name] = { + }, + [name]: { enumerable: true, - get: function get() { - return valueOrDefault(this[privateName], targetScopeObject[targetName]); + get() { + const local = this[privateName]; + const target = targetScopeObject[targetName]; + if (isObject(local)) { + return Object.assign({}, target, local); + } + return valueOrDefault(local, target); }, - set: function set(value) { + set(value) { this[privateName] = value; } - }, _Object$definePropert)); - }; - return Defaults; - }(); - const defaults = new Defaults(); - - const PI = Math.PI; - const TAU = 2 * PI; - const PITAU = TAU + PI; - const INFINITY = Number.POSITIVE_INFINITY; - const RAD_PER_DEG = PI / 180; - const HALF_PI = PI / 2; - const QUARTER_PI = PI / 4; - const TWO_THIRDS_PI = PI * 2 / 3; - function _factorize(value) { - const result = []; - const sqrt = Math.sqrt(value); - let i; - for (i = 1; i < sqrt; i++) { - if (value % i === 0) { - result.push(i); - result.push(value / i); } - } - if (sqrt === (sqrt | 0)) { - result.push(sqrt); - } - result.sort(function (a, b) { - return a - b; - }).pop(); - return result; + }); } - const log10 = Math.log10 || function (x) { - const exponent = Math.log(x) * Math.LOG10E; - const powerOf10 = Math.round(exponent); - const isPowerOf10 = x === Math.pow(10, powerOf10); - return isPowerOf10 ? powerOf10 : exponent; +} +var defaults = new Defaults({ + _scriptable: (name) => !name.startsWith('on'), + _indexable: (name) => name !== 'events', + hover: { + _fallback: 'interaction' + }, + interaction: { + _scriptable: false, + _indexable: false, + } +}); + +function _isDomSupported() { + return typeof window !== 'undefined' && typeof document !== 'undefined'; +} +function _getParentNode(domNode) { + let parent = domNode.parentNode; + if (parent && parent.toString() === '[object ShadowRoot]') { + parent = parent.host; + } + return parent; +} +function parseMaxStyle(styleValue, node, parentProperty) { + let valueInPixels; + if (typeof styleValue === 'string') { + valueInPixels = parseInt(styleValue, 10); + if (styleValue.indexOf('%') !== -1) { + valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty]; + } + } else { + valueInPixels = styleValue; + } + return valueInPixels; +} +const getComputedStyle = (element) => window.getComputedStyle(element, null); +function getStyle(el, property) { + return getComputedStyle(el).getPropertyValue(property); +} +const positions = ['top', 'right', 'bottom', 'left']; +function getPositionedStyle(styles, style, suffix) { + const result = {}; + suffix = suffix ? '-' + suffix : ''; + for (let i = 0; i < 4; i++) { + const pos = positions[i]; + result[pos] = parseFloat(styles[style + '-' + pos + suffix]) || 0; + } + result.width = result.left + result.right; + result.height = result.top + result.bottom; + return result; +} +const useOffsetPos = (x, y, target) => (x > 0 || y > 0) && (!target || !target.shadowRoot); +function getCanvasPosition(e, canvas) { + const touches = e.touches; + const source = touches && touches.length ? touches[0] : e; + const {offsetX, offsetY} = source; + let box = false; + let x, y; + if (useOffsetPos(offsetX, offsetY, e.target)) { + x = offsetX; + y = offsetY; + } else { + const rect = canvas.getBoundingClientRect(); + x = source.clientX - rect.left; + y = source.clientY - rect.top; + box = true; + } + return {x, y, box}; +} +function getRelativePosition(evt, chart) { + if ('native' in evt) { + return evt; + } + const {canvas, currentDevicePixelRatio} = chart; + const style = getComputedStyle(canvas); + const borderBox = style.boxSizing === 'border-box'; + const paddings = getPositionedStyle(style, 'padding'); + const borders = getPositionedStyle(style, 'border', 'width'); + const {x, y, box} = getCanvasPosition(evt, canvas); + const xOffset = paddings.left + (box && borders.left); + const yOffset = paddings.top + (box && borders.top); + let {width, height} = chart; + if (borderBox) { + width -= paddings.width + borders.width; + height -= paddings.height + borders.height; + } + return { + x: Math.round((x - xOffset) / width * canvas.width / currentDevicePixelRatio), + y: Math.round((y - yOffset) / height * canvas.height / currentDevicePixelRatio) }; - function isNumber(n) { - return !isNaN(parseFloat(n)) && isFinite(n); +} +function getContainerSize(canvas, width, height) { + let maxWidth, maxHeight; + if (width === undefined || height === undefined) { + const container = _getParentNode(canvas); + if (!container) { + width = canvas.clientWidth; + height = canvas.clientHeight; + } else { + const rect = container.getBoundingClientRect(); + const containerStyle = getComputedStyle(container); + const containerBorder = getPositionedStyle(containerStyle, 'border', 'width'); + const containerPadding = getPositionedStyle(containerStyle, 'padding'); + width = rect.width - containerPadding.width - containerBorder.width; + height = rect.height - containerPadding.height - containerBorder.height; + maxWidth = parseMaxStyle(containerStyle.maxWidth, container, 'clientWidth'); + maxHeight = parseMaxStyle(containerStyle.maxHeight, container, 'clientHeight'); + } + } + return { + width, + height, + maxWidth: maxWidth || INFINITY, + maxHeight: maxHeight || INFINITY + }; +} +const round1 = v => Math.round(v * 10) / 10; +function getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) { + const style = getComputedStyle(canvas); + const margins = getPositionedStyle(style, 'margin'); + const maxWidth = parseMaxStyle(style.maxWidth, canvas, 'clientWidth') || INFINITY; + const maxHeight = parseMaxStyle(style.maxHeight, canvas, 'clientHeight') || INFINITY; + const containerSize = getContainerSize(canvas, bbWidth, bbHeight); + let {width, height} = containerSize; + if (style.boxSizing === 'content-box') { + const borders = getPositionedStyle(style, 'border', 'width'); + const paddings = getPositionedStyle(style, 'padding'); + width -= paddings.width + borders.width; + height -= paddings.height + borders.height; + } + width = Math.max(0, width - margins.width); + height = Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height - margins.height); + width = round1(Math.min(width, maxWidth, containerSize.maxWidth)); + height = round1(Math.min(height, maxHeight, containerSize.maxHeight)); + if (width && !height) { + height = round1(width / 2); + } + return { + width, + height + }; +} +function retinaScale(chart, forceRatio, forceStyle) { + const pixelRatio = forceRatio || 1; + const deviceHeight = Math.floor(chart.height * pixelRatio); + const deviceWidth = Math.floor(chart.width * pixelRatio); + chart.height = deviceHeight / pixelRatio; + chart.width = deviceWidth / pixelRatio; + const canvas = chart.canvas; + if (canvas.style && (forceStyle || (!canvas.style.height && !canvas.style.width))) { + canvas.style.height = `${chart.height}px`; + canvas.style.width = `${chart.width}px`; + } + if (chart.currentDevicePixelRatio !== pixelRatio + || canvas.height !== deviceHeight + || canvas.width !== deviceWidth) { + chart.currentDevicePixelRatio = pixelRatio; + canvas.height = deviceHeight; + canvas.width = deviceWidth; + chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0); + return true; } - function almostEquals(x, y, epsilon) { - return Math.abs(x - y) < epsilon; + return false; +} +const supportsEventListenerOptions = (function() { + let passiveSupported = false; + try { + const options = { + get passive() { + passiveSupported = true; + return false; + } + }; + window.addEventListener('test', null, options); + window.removeEventListener('test', null, options); + } catch (e) { } - function almostWhole(x, epsilon) { - const rounded = Math.round(x); - return rounded - epsilon <= x && rounded + epsilon >= x; + return passiveSupported; +}()); +function readUsedSize(element, property) { + const value = getStyle(element, property); + const matches = value && value.match(/^(\d+)(\.\d+)?px$/); + return matches ? +matches[1] : undefined; +} + +function toFontString(font) { + if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) { + return null; } - function _setMinAndMaxByKey(array, target, property) { - let i, ilen, value; - for (i = 0, ilen = array.length; i < ilen; i++) { - value = array[i][property]; - if (!isNaN(value)) { - target.min = Math.min(target.min, value); - target.max = Math.max(target.max, value); - } + return (font.style ? font.style + ' ' : '') + + (font.weight ? font.weight + ' ' : '') + + font.size + 'px ' + + font.family; +} +function _measureText(ctx, data, gc, longest, string) { + let textWidth = data[string]; + if (!textWidth) { + textWidth = data[string] = ctx.measureText(string).width; + gc.push(string); + } + if (textWidth > longest) { + longest = textWidth; + } + return longest; +} +function _longestText(ctx, font, arrayOfThings, cache) { + cache = cache || {}; + let data = cache.data = cache.data || {}; + let gc = cache.garbageCollect = cache.garbageCollect || []; + if (cache.font !== font) { + data = cache.data = {}; + gc = cache.garbageCollect = []; + cache.font = font; + } + ctx.save(); + ctx.font = font; + let longest = 0; + const ilen = arrayOfThings.length; + let i, j, jlen, thing, nestedThing; + for (i = 0; i < ilen; i++) { + thing = arrayOfThings[i]; + if (thing !== undefined && thing !== null && isArray(thing) !== true) { + longest = _measureText(ctx, data, gc, longest, thing); + } else if (isArray(thing)) { + for (j = 0, jlen = thing.length; j < jlen; j++) { + nestedThing = thing[j]; + if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) { + longest = _measureText(ctx, data, gc, longest, nestedThing); + } + } + } + } + ctx.restore(); + const gcLen = gc.length / 2; + if (gcLen > arrayOfThings.length) { + for (i = 0; i < gcLen; i++) { + delete data[gc[i]]; + } + gc.splice(0, gcLen); + } + return longest; +} +function _alignPixel(chart, pixel, width) { + const devicePixelRatio = chart.currentDevicePixelRatio; + const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0; + return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth; +} +function clearCanvas(canvas, ctx) { + ctx = ctx || canvas.getContext('2d'); + ctx.save(); + ctx.resetTransform(); + ctx.clearRect(0, 0, canvas.width, canvas.height); + ctx.restore(); +} +function drawPoint(ctx, options, x, y) { + drawPointLegend(ctx, options, x, y, null); +} +function drawPointLegend(ctx, options, x, y, w) { + let type, xOffset, yOffset, size, cornerRadius, width; + const style = options.pointStyle; + const rotation = options.rotation; + const radius = options.radius; + let rad = (rotation || 0) * RAD_PER_DEG; + if (style && typeof style === 'object') { + type = style.toString(); + if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') { + ctx.save(); + ctx.translate(x, y); + ctx.rotate(rad); + ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height); + ctx.restore(); + return; } } - const sign = Math.sign ? function (x) { - return Math.sign(x); - } : function (x) { - x = +x; - if (x === 0 || isNaN(x)) { - return x; + if (isNaN(radius) || radius <= 0) { + return; + } + ctx.beginPath(); + switch (style) { + default: + if (w) { + ctx.ellipse(x, y, w / 2, radius, 0, 0, TAU); + } else { + ctx.arc(x, y, radius, 0, TAU); } - return x > 0 ? 1 : -1; - }; - function toRadians(degrees) { - return degrees * (PI / 180); + ctx.closePath(); + break; + case 'triangle': + ctx.moveTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); + rad += TWO_THIRDS_PI; + ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); + rad += TWO_THIRDS_PI; + ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); + ctx.closePath(); + break; + case 'rectRounded': + cornerRadius = radius * 0.516; + size = radius - cornerRadius; + xOffset = Math.cos(rad + QUARTER_PI) * size; + yOffset = Math.sin(rad + QUARTER_PI) * size; + ctx.arc(x - xOffset, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI); + ctx.arc(x + yOffset, y - xOffset, cornerRadius, rad - HALF_PI, rad); + ctx.arc(x + xOffset, y + yOffset, cornerRadius, rad, rad + HALF_PI); + ctx.arc(x - yOffset, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI); + ctx.closePath(); + break; + case 'rect': + if (!rotation) { + size = Math.SQRT1_2 * radius; + width = w ? w / 2 : size; + ctx.rect(x - width, y - size, 2 * width, 2 * size); + break; + } + rad += QUARTER_PI; + case 'rectRot': + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + yOffset, y - xOffset); + ctx.lineTo(x + xOffset, y + yOffset); + ctx.lineTo(x - yOffset, y + xOffset); + ctx.closePath(); + break; + case 'crossRot': + rad += QUARTER_PI; + case 'cross': + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + xOffset, y + yOffset); + ctx.moveTo(x + yOffset, y - xOffset); + ctx.lineTo(x - yOffset, y + xOffset); + break; + case 'star': + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + xOffset, y + yOffset); + ctx.moveTo(x + yOffset, y - xOffset); + ctx.lineTo(x - yOffset, y + xOffset); + rad += QUARTER_PI; + xOffset = Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + xOffset, y + yOffset); + ctx.moveTo(x + yOffset, y - xOffset); + ctx.lineTo(x - yOffset, y + xOffset); + break; + case 'line': + xOffset = w ? w / 2 : Math.cos(rad) * radius; + yOffset = Math.sin(rad) * radius; + ctx.moveTo(x - xOffset, y - yOffset); + ctx.lineTo(x + xOffset, y + yOffset); + break; + case 'dash': + ctx.moveTo(x, y); + ctx.lineTo(x + Math.cos(rad) * radius, y + Math.sin(rad) * radius); + break; + } + ctx.fill(); + if (options.borderWidth > 0) { + ctx.stroke(); } - function toDegrees(radians) { - return radians * (180 / PI); +} +function _isPointInArea(point, area, margin) { + margin = margin || 0.5; + return !area || (point && point.x > area.left - margin && point.x < area.right + margin && + point.y > area.top - margin && point.y < area.bottom + margin); +} +function clipArea(ctx, area) { + ctx.save(); + ctx.beginPath(); + ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top); + ctx.clip(); +} +function unclipArea(ctx) { + ctx.restore(); +} +function _steppedLineTo(ctx, previous, target, flip, mode) { + if (!previous) { + return ctx.lineTo(target.x, target.y); + } + if (mode === 'middle') { + const midpoint = (previous.x + target.x) / 2.0; + ctx.lineTo(midpoint, previous.y); + ctx.lineTo(midpoint, target.y); + } else if (mode === 'after' !== !!flip) { + ctx.lineTo(previous.x, target.y); + } else { + ctx.lineTo(target.x, previous.y); + } + ctx.lineTo(target.x, target.y); +} +function _bezierCurveTo(ctx, previous, target, flip) { + if (!previous) { + return ctx.lineTo(target.x, target.y); + } + ctx.bezierCurveTo( + flip ? previous.cp1x : previous.cp2x, + flip ? previous.cp1y : previous.cp2y, + flip ? target.cp2x : target.cp1x, + flip ? target.cp2y : target.cp1y, + target.x, + target.y); +} +function renderText(ctx, text, x, y, font, opts = {}) { + const lines = isArray(text) ? text : [text]; + const stroke = opts.strokeWidth > 0 && opts.strokeColor !== ''; + let i, line; + ctx.save(); + ctx.font = font.string; + setRenderOpts(ctx, opts); + for (i = 0; i < lines.length; ++i) { + line = lines[i]; + if (stroke) { + if (opts.strokeColor) { + ctx.strokeStyle = opts.strokeColor; + } + if (!isNullOrUndef(opts.strokeWidth)) { + ctx.lineWidth = opts.strokeWidth; + } + ctx.strokeText(line, x, y, opts.maxWidth); + } + ctx.fillText(line, x, y, opts.maxWidth); + decorateText(ctx, x, y, line, opts); + y += font.lineHeight; + } + ctx.restore(); +} +function setRenderOpts(ctx, opts) { + if (opts.translation) { + ctx.translate(opts.translation[0], opts.translation[1]); + } + if (!isNullOrUndef(opts.rotation)) { + ctx.rotate(opts.rotation); + } + if (opts.color) { + ctx.fillStyle = opts.color; + } + if (opts.textAlign) { + ctx.textAlign = opts.textAlign; + } + if (opts.textBaseline) { + ctx.textBaseline = opts.textBaseline; + } +} +function decorateText(ctx, x, y, line, opts) { + if (opts.strikethrough || opts.underline) { + const metrics = ctx.measureText(line); + const left = x - metrics.actualBoundingBoxLeft; + const right = x + metrics.actualBoundingBoxRight; + const top = y - metrics.actualBoundingBoxAscent; + const bottom = y + metrics.actualBoundingBoxDescent; + const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom; + ctx.strokeStyle = ctx.fillStyle; + ctx.beginPath(); + ctx.lineWidth = opts.decorationWidth || 2; + ctx.moveTo(left, yDecoration); + ctx.lineTo(right, yDecoration); + ctx.stroke(); } - function _decimalPlaces(x) { - if (!isNumberFinite(x)) { - return; +} +function addRoundedRectPath(ctx, rect) { + const {x, y, w, h, radius} = rect; + ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, -HALF_PI, PI, true); + ctx.lineTo(x, y + h - radius.bottomLeft); + ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true); + ctx.lineTo(x + w - radius.bottomRight, y + h); + ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true); + ctx.lineTo(x + w, y + radius.topRight); + ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true); + ctx.lineTo(x + radius.topLeft, y); +} + +function _createResolver(scopes, prefixes = [''], rootScopes = scopes, fallback, getTarget = () => scopes[0]) { + if (!defined(fallback)) { + fallback = _resolve('_fallback', scopes); + } + const cache = { + [Symbol.toStringTag]: 'Object', + _cacheable: true, + _scopes: scopes, + _rootScopes: rootScopes, + _fallback: fallback, + _getTarget: getTarget, + override: (scope) => _createResolver([scope, ...scopes], prefixes, rootScopes, fallback), + }; + return new Proxy(cache, { + deleteProperty(target, prop) { + delete target[prop]; + delete target._keys; + delete scopes[0][prop]; + return true; + }, + get(target, prop) { + return _cached(target, prop, + () => _resolveWithPrefixes(prop, prefixes, scopes, target)); + }, + getOwnPropertyDescriptor(target, prop) { + return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop); + }, + getPrototypeOf() { + return Reflect.getPrototypeOf(scopes[0]); + }, + has(target, prop) { + return getKeysFromAllScopes(target).includes(prop); + }, + ownKeys(target) { + return getKeysFromAllScopes(target); + }, + set(target, prop, value) { + const storage = target._storage || (target._storage = getTarget()); + target[prop] = storage[prop] = value; + delete target._keys; + return true; } - let e = 1; - let p = 0; - while (Math.round(x * e) / e !== x) { - e *= 10; - p++; + }); +} +function _attachContext(proxy, context, subProxy, descriptorDefaults) { + const cache = { + _cacheable: false, + _proxy: proxy, + _context: context, + _subProxy: subProxy, + _stack: new Set(), + _descriptors: _descriptors(proxy, descriptorDefaults), + setContext: (ctx) => _attachContext(proxy, ctx, subProxy, descriptorDefaults), + override: (scope) => _attachContext(proxy.override(scope), context, subProxy, descriptorDefaults) + }; + return new Proxy(cache, { + deleteProperty(target, prop) { + delete target[prop]; + delete proxy[prop]; + return true; + }, + get(target, prop, receiver) { + return _cached(target, prop, + () => _resolveWithContext(target, prop, receiver)); + }, + getOwnPropertyDescriptor(target, prop) { + return target._descriptors.allKeys + ? Reflect.has(proxy, prop) ? {enumerable: true, configurable: true} : undefined + : Reflect.getOwnPropertyDescriptor(proxy, prop); + }, + getPrototypeOf() { + return Reflect.getPrototypeOf(proxy); + }, + has(target, prop) { + return Reflect.has(proxy, prop); + }, + ownKeys() { + return Reflect.ownKeys(proxy); + }, + set(target, prop, value) { + proxy[prop] = value; + delete target[prop]; + return true; } - return p; - } - function getAngleFromPoint(centrePoint, anglePoint) { - const distanceFromXCenter = anglePoint.x - centrePoint.x; - const distanceFromYCenter = anglePoint.y - centrePoint.y; - const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter); - let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter); - if (angle < -0.5 * PI) { - angle += TAU; + }); +} +function _descriptors(proxy, defaults = {scriptable: true, indexable: true}) { + const {_scriptable = defaults.scriptable, _indexable = defaults.indexable, _allKeys = defaults.allKeys} = proxy; + return { + allKeys: _allKeys, + scriptable: _scriptable, + indexable: _indexable, + isScriptable: isFunction(_scriptable) ? _scriptable : () => _scriptable, + isIndexable: isFunction(_indexable) ? _indexable : () => _indexable + }; +} +const readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name; +const needsSubResolver = (prop, value) => isObject(value) && prop !== 'adapters' && + (Object.getPrototypeOf(value) === null || value.constructor === Object); +function _cached(target, prop, resolve) { + if (Object.prototype.hasOwnProperty.call(target, prop)) { + return target[prop]; + } + const value = resolve(); + target[prop] = value; + return value; +} +function _resolveWithContext(target, prop, receiver) { + const {_proxy, _context, _subProxy, _descriptors: descriptors} = target; + let value = _proxy[prop]; + if (isFunction(value) && descriptors.isScriptable(prop)) { + value = _resolveScriptable(prop, value, target, receiver); + } + if (isArray(value) && value.length) { + value = _resolveArray(prop, value, target, descriptors.isIndexable); + } + if (needsSubResolver(prop, value)) { + value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors); + } + return value; +} +function _resolveScriptable(prop, value, target, receiver) { + const {_proxy, _context, _subProxy, _stack} = target; + if (_stack.has(prop)) { + throw new Error('Recursion detected: ' + Array.from(_stack).join('->') + '->' + prop); + } + _stack.add(prop); + value = value(_context, _subProxy || receiver); + _stack.delete(prop); + if (needsSubResolver(prop, value)) { + value = createSubResolver(_proxy._scopes, _proxy, prop, value); + } + return value; +} +function _resolveArray(prop, value, target, isIndexable) { + const {_proxy, _context, _subProxy, _descriptors: descriptors} = target; + if (defined(_context.index) && isIndexable(prop)) { + value = value[_context.index % value.length]; + } else if (isObject(value[0])) { + const arr = value; + const scopes = _proxy._scopes.filter(s => s !== arr); + value = []; + for (const item of arr) { + const resolver = createSubResolver(scopes, _proxy, prop, item); + value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors)); + } + } + return value; +} +function resolveFallback(fallback, prop, value) { + return isFunction(fallback) ? fallback(prop, value) : fallback; +} +const getScope = (key, parent) => key === true ? parent + : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined; +function addScopes(set, parentScopes, key, parentFallback, value) { + for (const parent of parentScopes) { + const scope = getScope(key, parent); + if (scope) { + set.add(scope); + const fallback = resolveFallback(scope._fallback, key, value); + if (defined(fallback) && fallback !== key && fallback !== parentFallback) { + return fallback; + } + } else if (scope === false && defined(parentFallback) && key !== parentFallback) { + return null; } - return { - angle: angle, - distance: radialDistanceFromCenter - }; } - function distanceBetweenPoints(pt1, pt2) { - return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2)); + return false; +} +function createSubResolver(parentScopes, resolver, prop, value) { + const rootScopes = resolver._rootScopes; + const fallback = resolveFallback(resolver._fallback, prop, value); + const allScopes = [...parentScopes, ...rootScopes]; + const set = new Set(); + set.add(value); + let key = addScopesFromKey(set, allScopes, prop, fallback || prop, value); + if (key === null) { + return false; } - function _angleDiff(a, b) { - return (a - b + PITAU) % TAU - PI; + if (defined(fallback) && fallback !== prop) { + key = addScopesFromKey(set, allScopes, fallback, key, value); + if (key === null) { + return false; + } } - function _normalizeAngle(a) { - return (a % TAU + TAU) % TAU; + return _createResolver(Array.from(set), [''], rootScopes, fallback, + () => subGetTarget(resolver, prop, value)); +} +function addScopesFromKey(set, allScopes, key, fallback, item) { + while (key) { + key = addScopes(set, allScopes, key, fallback, item); } - function _angleBetween(angle, start, end) { - const a = _normalizeAngle(angle); - const s = _normalizeAngle(start); - const e = _normalizeAngle(end); - const angleToStart = _normalizeAngle(s - a); - const angleToEnd = _normalizeAngle(e - a); - const startToAngle = _normalizeAngle(a - s); - const endToAngle = _normalizeAngle(a - e); - return a === s || a === e || angleToStart > angleToEnd && startToAngle < endToAngle; + return key; +} +function subGetTarget(resolver, prop, value) { + const parent = resolver._getTarget(); + if (!(prop in parent)) { + parent[prop] = {}; } - function _limitValue(value, min, max) { - return Math.max(min, Math.min(max, value)); + const target = parent[prop]; + if (isArray(target) && isObject(value)) { + return value; } - function _int16Range(value) { - return _limitValue(value, -32768, 32767); + return target; +} +function _resolveWithPrefixes(prop, prefixes, scopes, proxy) { + let value; + for (const prefix of prefixes) { + value = _resolve(readKey(prefix, prop), scopes); + if (defined(value)) { + return needsSubResolver(prop, value) + ? createSubResolver(scopes, proxy, prop, value) + : value; + } + } +} +function _resolve(key, scopes) { + for (const scope of scopes) { + if (!scope) { + continue; + } + const value = scope[key]; + if (defined(value)) { + return value; + } } +} +function getKeysFromAllScopes(target) { + let keys = target._keys; + if (!keys) { + keys = target._keys = resolveKeysFromAllScopes(target._scopes); + } + return keys; +} +function resolveKeysFromAllScopes(scopes) { + const set = new Set(); + for (const scope of scopes) { + for (const key of Object.keys(scope).filter(k => !k.startsWith('_'))) { + set.add(key); + } + } + return Array.from(set); +} +function _parseObjectDataRadialScale(meta, data, start, count) { + const {iScale} = meta; + const {key = 'r'} = this._parsing; + const parsed = new Array(count); + let i, ilen, index, item; + for (i = 0, ilen = count; i < ilen; ++i) { + index = i + start; + item = data[index]; + parsed[i] = { + r: iScale.parse(resolveObjectKey(item, key), index) + }; + } + return parsed; +} - function toFontString(font) { - if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) { - return null; +const EPSILON = Number.EPSILON || 1e-14; +const getPoint = (points, i) => i < points.length && !points[i].skip && points[i]; +const getValueAxis = (indexAxis) => indexAxis === 'x' ? 'y' : 'x'; +function splineCurve(firstPoint, middlePoint, afterPoint, t) { + const previous = firstPoint.skip ? middlePoint : firstPoint; + const current = middlePoint; + const next = afterPoint.skip ? middlePoint : afterPoint; + const d01 = distanceBetweenPoints(current, previous); + const d12 = distanceBetweenPoints(next, current); + let s01 = d01 / (d01 + d12); + let s12 = d12 / (d01 + d12); + s01 = isNaN(s01) ? 0 : s01; + s12 = isNaN(s12) ? 0 : s12; + const fa = t * s01; + const fb = t * s12; + return { + previous: { + x: current.x - fa * (next.x - previous.x), + y: current.y - fa * (next.y - previous.y) + }, + next: { + x: current.x + fb * (next.x - previous.x), + y: current.y + fb * (next.y - previous.y) } - return (font.style ? font.style + ' ' : '') + (font.weight ? font.weight + ' ' : '') + font.size + 'px ' + font.family; - } - function _measureText(ctx, data, gc, longest, string) { - let textWidth = data[string]; - if (!textWidth) { - textWidth = data[string] = ctx.measureText(string).width; - gc.push(string); - } - if (textWidth > longest) { - longest = textWidth; - } - return longest; - } - function _longestText(ctx, font, arrayOfThings, cache) { - cache = cache || {}; - let data = cache.data = cache.data || {}; - let gc = cache.garbageCollect = cache.garbageCollect || []; - if (cache.font !== font) { - data = cache.data = {}; - gc = cache.garbageCollect = []; - cache.font = font; - } - ctx.save(); - ctx.font = font; - let longest = 0; - const ilen = arrayOfThings.length; - let i, j, jlen, thing, nestedThing; - for (i = 0; i < ilen; i++) { - thing = arrayOfThings[i]; - if (thing !== undefined && thing !== null && isArray(thing) !== true) { - longest = _measureText(ctx, data, gc, longest, thing); - } else if (isArray(thing)) { - for (j = 0, jlen = thing.length; j < jlen; j++) { - nestedThing = thing[j]; - if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) { - longest = _measureText(ctx, data, gc, longest, nestedThing); - } - } - } - } - ctx.restore(); - const gcLen = gc.length / 2; - if (gcLen > arrayOfThings.length) { - for (i = 0; i < gcLen; i++) { - delete data[gc[i]]; - } - gc.splice(0, gcLen); - } - return longest; - } - function _alignPixel(chart, pixel, width) { - const devicePixelRatio = chart.currentDevicePixelRatio; - const halfWidth = width / 2; - return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth; - } - function clear(chart) { - chart.ctx.clearRect(0, 0, chart.width, chart.height); - } - function drawPoint(ctx, options, x, y) { - let type, xOffset, yOffset, size, cornerRadius; - const style = options.pointStyle; - const rotation = options.rotation; - const radius = options.radius; - let rad = (rotation || 0) * RAD_PER_DEG; - if (style && typeof style === 'object') { - type = style.toString(); - if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') { - ctx.save(); - ctx.translate(x, y); - ctx.rotate(rad); - ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height); - ctx.restore(); - return; - } - } - if (isNaN(radius) || radius <= 0) { - return; - } - ctx.beginPath(); - switch (style) { - default: - ctx.arc(x, y, radius, 0, TAU); - ctx.closePath(); - break; - case 'triangle': - ctx.moveTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); - rad += TWO_THIRDS_PI; - ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); - rad += TWO_THIRDS_PI; - ctx.lineTo(x + Math.sin(rad) * radius, y - Math.cos(rad) * radius); - ctx.closePath(); - break; - case 'rectRounded': - cornerRadius = radius * 0.516; - size = radius - cornerRadius; - xOffset = Math.cos(rad + QUARTER_PI) * size; - yOffset = Math.sin(rad + QUARTER_PI) * size; - ctx.arc(x - xOffset, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI); - ctx.arc(x + yOffset, y - xOffset, cornerRadius, rad - HALF_PI, rad); - ctx.arc(x + xOffset, y + yOffset, cornerRadius, rad, rad + HALF_PI); - ctx.arc(x - yOffset, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI); - ctx.closePath(); - break; - case 'rect': - if (!rotation) { - size = Math.SQRT1_2 * radius; - ctx.rect(x - size, y - size, 2 * size, 2 * size); - break; - } - rad += QUARTER_PI; - case 'rectRot': - xOffset = Math.cos(rad) * radius; - yOffset = Math.sin(rad) * radius; - ctx.moveTo(x - xOffset, y - yOffset); - ctx.lineTo(x + yOffset, y - xOffset); - ctx.lineTo(x + xOffset, y + yOffset); - ctx.lineTo(x - yOffset, y + xOffset); - ctx.closePath(); - break; - case 'crossRot': - rad += QUARTER_PI; - case 'cross': - xOffset = Math.cos(rad) * radius; - yOffset = Math.sin(rad) * radius; - ctx.moveTo(x - xOffset, y - yOffset); - ctx.lineTo(x + xOffset, y + yOffset); - ctx.moveTo(x + yOffset, y - xOffset); - ctx.lineTo(x - yOffset, y + xOffset); - break; - case 'star': - xOffset = Math.cos(rad) * radius; - yOffset = Math.sin(rad) * radius; - ctx.moveTo(x - xOffset, y - yOffset); - ctx.lineTo(x + xOffset, y + yOffset); - ctx.moveTo(x + yOffset, y - xOffset); - ctx.lineTo(x - yOffset, y + xOffset); - rad += QUARTER_PI; - xOffset = Math.cos(rad) * radius; - yOffset = Math.sin(rad) * radius; - ctx.moveTo(x - xOffset, y - yOffset); - ctx.lineTo(x + xOffset, y + yOffset); - ctx.moveTo(x + yOffset, y - xOffset); - ctx.lineTo(x - yOffset, y + xOffset); - break; - case 'line': - xOffset = Math.cos(rad) * radius; - yOffset = Math.sin(rad) * radius; - ctx.moveTo(x - xOffset, y - yOffset); - ctx.lineTo(x + xOffset, y + yOffset); - break; - case 'dash': - ctx.moveTo(x, y); - ctx.lineTo(x + Math.cos(rad) * radius, y + Math.sin(rad) * radius); - break; - } - ctx.fill(); - if (options.borderWidth > 0) { - ctx.stroke(); + }; +} +function monotoneAdjust(points, deltaK, mK) { + const pointsLen = points.length; + let alphaK, betaK, tauK, squaredMagnitude, pointCurrent; + let pointAfter = getPoint(points, 0); + for (let i = 0; i < pointsLen - 1; ++i) { + pointCurrent = pointAfter; + pointAfter = getPoint(points, i + 1); + if (!pointCurrent || !pointAfter) { + continue; + } + if (almostEquals(deltaK[i], 0, EPSILON)) { + mK[i] = mK[i + 1] = 0; + continue; + } + alphaK = mK[i] / deltaK[i]; + betaK = mK[i + 1] / deltaK[i]; + squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2); + if (squaredMagnitude <= 9) { + continue; + } + tauK = 3 / Math.sqrt(squaredMagnitude); + mK[i] = alphaK * tauK * deltaK[i]; + mK[i + 1] = betaK * tauK * deltaK[i]; + } +} +function monotoneCompute(points, mK, indexAxis = 'x') { + const valueAxis = getValueAxis(indexAxis); + const pointsLen = points.length; + let delta, pointBefore, pointCurrent; + let pointAfter = getPoint(points, 0); + for (let i = 0; i < pointsLen; ++i) { + pointBefore = pointCurrent; + pointCurrent = pointAfter; + pointAfter = getPoint(points, i + 1); + if (!pointCurrent) { + continue; + } + const iPixel = pointCurrent[indexAxis]; + const vPixel = pointCurrent[valueAxis]; + if (pointBefore) { + delta = (iPixel - pointBefore[indexAxis]) / 3; + pointCurrent[`cp1${indexAxis}`] = iPixel - delta; + pointCurrent[`cp1${valueAxis}`] = vPixel - delta * mK[i]; + } + if (pointAfter) { + delta = (pointAfter[indexAxis] - iPixel) / 3; + pointCurrent[`cp2${indexAxis}`] = iPixel + delta; + pointCurrent[`cp2${valueAxis}`] = vPixel + delta * mK[i]; + } + } +} +function splineCurveMonotone(points, indexAxis = 'x') { + const valueAxis = getValueAxis(indexAxis); + const pointsLen = points.length; + const deltaK = Array(pointsLen).fill(0); + const mK = Array(pointsLen); + let i, pointBefore, pointCurrent; + let pointAfter = getPoint(points, 0); + for (i = 0; i < pointsLen; ++i) { + pointBefore = pointCurrent; + pointCurrent = pointAfter; + pointAfter = getPoint(points, i + 1); + if (!pointCurrent) { + continue; + } + if (pointAfter) { + const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis]; + deltaK[i] = slopeDelta !== 0 ? (pointAfter[valueAxis] - pointCurrent[valueAxis]) / slopeDelta : 0; + } + mK[i] = !pointBefore ? deltaK[i] + : !pointAfter ? deltaK[i - 1] + : (sign(deltaK[i - 1]) !== sign(deltaK[i])) ? 0 + : (deltaK[i - 1] + deltaK[i]) / 2; + } + monotoneAdjust(points, deltaK, mK); + monotoneCompute(points, mK, indexAxis); +} +function capControlPoint(pt, min, max) { + return Math.max(Math.min(pt, max), min); +} +function capBezierPoints(points, area) { + let i, ilen, point, inArea, inAreaPrev; + let inAreaNext = _isPointInArea(points[0], area); + for (i = 0, ilen = points.length; i < ilen; ++i) { + inAreaPrev = inArea; + inArea = inAreaNext; + inAreaNext = i < ilen - 1 && _isPointInArea(points[i + 1], area); + if (!inArea) { + continue; + } + point = points[i]; + if (inAreaPrev) { + point.cp1x = capControlPoint(point.cp1x, area.left, area.right); + point.cp1y = capControlPoint(point.cp1y, area.top, area.bottom); + } + if (inAreaNext) { + point.cp2x = capControlPoint(point.cp2x, area.left, area.right); + point.cp2y = capControlPoint(point.cp2y, area.top, area.bottom); + } + } +} +function _updateBezierControlPoints(points, options, area, loop, indexAxis) { + let i, ilen, point, controlPoints; + if (options.spanGaps) { + points = points.filter((pt) => !pt.skip); + } + if (options.cubicInterpolationMode === 'monotone') { + splineCurveMonotone(points, indexAxis); + } else { + let prev = loop ? points[points.length - 1] : points[0]; + for (i = 0, ilen = points.length; i < ilen; ++i) { + point = points[i]; + controlPoints = splineCurve( + prev, + point, + points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen], + options.tension + ); + point.cp1x = controlPoints.previous.x; + point.cp1y = controlPoints.previous.y; + point.cp2x = controlPoints.next.x; + point.cp2y = controlPoints.next.y; + prev = point; } } - function _isPointInArea(point, area) { - const epsilon = 0.5; - return point.x > area.left - epsilon && point.x < area.right + epsilon && point.y > area.top - epsilon && point.y < area.bottom + epsilon; - } - function clipArea(ctx, area) { - ctx.save(); - ctx.beginPath(); - ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top); - ctx.clip(); - } - function unclipArea(ctx) { - ctx.restore(); + if (options.capBezierPoints) { + capBezierPoints(points, area); } - function _steppedLineTo(ctx, previous, target, flip, mode) { - if (!previous) { - return ctx.lineTo(target.x, target.y); - } - if (mode === 'middle') { - const midpoint = (previous.x + target.x) / 2.0; - ctx.lineTo(midpoint, previous.y); - ctx.lineTo(midpoint, target.y); - } else if (mode === 'after' !== !!flip) { - ctx.lineTo(previous.x, target.y); - } else { - ctx.lineTo(target.x, previous.y); +} + +const atEdge = (t) => t === 0 || t === 1; +const elasticIn = (t, s, p) => -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p)); +const elasticOut = (t, s, p) => Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1; +const effects = { + linear: t => t, + easeInQuad: t => t * t, + easeOutQuad: t => -t * (t - 2), + easeInOutQuad: t => ((t /= 0.5) < 1) + ? 0.5 * t * t + : -0.5 * ((--t) * (t - 2) - 1), + easeInCubic: t => t * t * t, + easeOutCubic: t => (t -= 1) * t * t + 1, + easeInOutCubic: t => ((t /= 0.5) < 1) + ? 0.5 * t * t * t + : 0.5 * ((t -= 2) * t * t + 2), + easeInQuart: t => t * t * t * t, + easeOutQuart: t => -((t -= 1) * t * t * t - 1), + easeInOutQuart: t => ((t /= 0.5) < 1) + ? 0.5 * t * t * t * t + : -0.5 * ((t -= 2) * t * t * t - 2), + easeInQuint: t => t * t * t * t * t, + easeOutQuint: t => (t -= 1) * t * t * t * t + 1, + easeInOutQuint: t => ((t /= 0.5) < 1) + ? 0.5 * t * t * t * t * t + : 0.5 * ((t -= 2) * t * t * t * t + 2), + easeInSine: t => -Math.cos(t * HALF_PI) + 1, + easeOutSine: t => Math.sin(t * HALF_PI), + easeInOutSine: t => -0.5 * (Math.cos(PI * t) - 1), + easeInExpo: t => (t === 0) ? 0 : Math.pow(2, 10 * (t - 1)), + easeOutExpo: t => (t === 1) ? 1 : -Math.pow(2, -10 * t) + 1, + easeInOutExpo: t => atEdge(t) ? t : t < 0.5 + ? 0.5 * Math.pow(2, 10 * (t * 2 - 1)) + : 0.5 * (-Math.pow(2, -10 * (t * 2 - 1)) + 2), + easeInCirc: t => (t >= 1) ? t : -(Math.sqrt(1 - t * t) - 1), + easeOutCirc: t => Math.sqrt(1 - (t -= 1) * t), + easeInOutCirc: t => ((t /= 0.5) < 1) + ? -0.5 * (Math.sqrt(1 - t * t) - 1) + : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1), + easeInElastic: t => atEdge(t) ? t : elasticIn(t, 0.075, 0.3), + easeOutElastic: t => atEdge(t) ? t : elasticOut(t, 0.075, 0.3), + easeInOutElastic(t) { + const s = 0.1125; + const p = 0.45; + return atEdge(t) ? t : + t < 0.5 + ? 0.5 * elasticIn(t * 2, s, p) + : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p); + }, + easeInBack(t) { + const s = 1.70158; + return t * t * ((s + 1) * t - s); + }, + easeOutBack(t) { + const s = 1.70158; + return (t -= 1) * t * ((s + 1) * t + s) + 1; + }, + easeInOutBack(t) { + let s = 1.70158; + if ((t /= 0.5) < 1) { + return 0.5 * (t * t * (((s *= (1.525)) + 1) * t - s)); + } + return 0.5 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2); + }, + easeInBounce: t => 1 - effects.easeOutBounce(1 - t), + easeOutBounce(t) { + const m = 7.5625; + const d = 2.75; + if (t < (1 / d)) { + return m * t * t; + } + if (t < (2 / d)) { + return m * (t -= (1.5 / d)) * t + 0.75; + } + if (t < (2.5 / d)) { + return m * (t -= (2.25 / d)) * t + 0.9375; + } + return m * (t -= (2.625 / d)) * t + 0.984375; + }, + easeInOutBounce: t => (t < 0.5) + ? effects.easeInBounce(t * 2) * 0.5 + : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5, +}; + +function _pointInLine(p1, p2, t, mode) { + return { + x: p1.x + t * (p2.x - p1.x), + y: p1.y + t * (p2.y - p1.y) + }; +} +function _steppedInterpolation(p1, p2, t, mode) { + return { + x: p1.x + t * (p2.x - p1.x), + y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y + : mode === 'after' ? t < 1 ? p1.y : p2.y + : t > 0 ? p2.y : p1.y + }; +} +function _bezierInterpolation(p1, p2, t, mode) { + const cp1 = {x: p1.cp2x, y: p1.cp2y}; + const cp2 = {x: p2.cp1x, y: p2.cp1y}; + const a = _pointInLine(p1, cp1, t); + const b = _pointInLine(cp1, cp2, t); + const c = _pointInLine(cp2, p2, t); + const d = _pointInLine(a, b, t); + const e = _pointInLine(b, c, t); + return _pointInLine(d, e, t); +} + +const intlCache = new Map(); +function getNumberFormat(locale, options) { + options = options || {}; + const cacheKey = locale + JSON.stringify(options); + let formatter = intlCache.get(cacheKey); + if (!formatter) { + formatter = new Intl.NumberFormat(locale, options); + intlCache.set(cacheKey, formatter); + } + return formatter; +} +function formatNumber(num, locale, options) { + return getNumberFormat(locale, options).format(num); +} + +const LINE_HEIGHT = new RegExp(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/); +const FONT_STYLE = new RegExp(/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/); +function toLineHeight(value, size) { + const matches = ('' + value).match(LINE_HEIGHT); + if (!matches || matches[1] === 'normal') { + return size * 1.2; + } + value = +matches[2]; + switch (matches[3]) { + case 'px': + return value; + case '%': + value /= 100; + break; + } + return size * value; +} +const numberOrZero = v => +v || 0; +function _readValueToProps(value, props) { + const ret = {}; + const objProps = isObject(props); + const keys = objProps ? Object.keys(props) : props; + const read = isObject(value) + ? objProps + ? prop => valueOrDefault(value[prop], value[props[prop]]) + : prop => value[prop] + : () => value; + for (const prop of keys) { + ret[prop] = numberOrZero(read(prop)); + } + return ret; +} +function toTRBL(value) { + return _readValueToProps(value, {top: 'y', right: 'x', bottom: 'y', left: 'x'}); +} +function toTRBLCorners(value) { + return _readValueToProps(value, ['topLeft', 'topRight', 'bottomLeft', 'bottomRight']); +} +function toPadding(value) { + const obj = toTRBL(value); + obj.width = obj.left + obj.right; + obj.height = obj.top + obj.bottom; + return obj; +} +function toFont(options, fallback) { + options = options || {}; + fallback = fallback || defaults.font; + let size = valueOrDefault(options.size, fallback.size); + if (typeof size === 'string') { + size = parseInt(size, 10); + } + let style = valueOrDefault(options.style, fallback.style); + if (style && !('' + style).match(FONT_STYLE)) { + console.warn('Invalid font style specified: "' + style + '"'); + style = ''; + } + const font = { + family: valueOrDefault(options.family, fallback.family), + lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size), + size, + style, + weight: valueOrDefault(options.weight, fallback.weight), + string: '' + }; + font.string = toFontString(font); + return font; +} +function resolve(inputs, context, index, info) { + let cacheable = true; + let i, ilen, value; + for (i = 0, ilen = inputs.length; i < ilen; ++i) { + value = inputs[i]; + if (value === undefined) { + continue; + } + if (context !== undefined && typeof value === 'function') { + value = value(context); + cacheable = false; + } + if (index !== undefined && isArray(value)) { + value = value[index % value.length]; + cacheable = false; } - ctx.lineTo(target.x, target.y); - } - function _bezierCurveTo(ctx, previous, target, flip) { - if (!previous) { - return ctx.lineTo(target.x, target.y); + if (value !== undefined) { + if (info && !cacheable) { + info.cacheable = false; + } + return value; } - ctx.bezierCurveTo(flip ? previous.controlPointPreviousX : previous.controlPointNextX, flip ? previous.controlPointPreviousY : previous.controlPointNextY, flip ? target.controlPointNextX : target.controlPointPreviousX, flip ? target.controlPointNextY : target.controlPointPreviousY, target.x, target.y); } +} +function _addGrace(minmax, grace, beginAtZero) { + const {min, max} = minmax; + const change = toDimension(grace, (max - min) / 2); + const keepZero = (value, add) => beginAtZero && value === 0 ? 0 : value + add; + return { + min: keepZero(min, -Math.abs(change)), + max: keepZero(max, change) + }; +} +function createContext(parentContext, context) { + return Object.assign(Object.create(parentContext), context); +} - function _lookup(table, value, cmp) { - cmp = cmp || function (index) { - return table[index] < value; - }; - let hi = table.length - 1; - let lo = 0; - let mid; - while (hi - lo > 1) { - mid = lo + hi >> 1; - if (cmp(mid)) { - lo = mid; - } else { - hi = mid; +const getRightToLeftAdapter = function(rectX, width) { + return { + x(x) { + return rectX + rectX + width - x; + }, + setWidth(w) { + width = w; + }, + textAlign(align) { + if (align === 'center') { + return align; } - } + return align === 'right' ? 'left' : 'right'; + }, + xPlus(x, value) { + return x - value; + }, + leftForLtr(x, itemWidth) { + return x - itemWidth; + }, + }; +}; +const getLeftToRightAdapter = function() { + return { + x(x) { + return x; + }, + setWidth(w) { + }, + textAlign(align) { + return align; + }, + xPlus(x, value) { + return x + value; + }, + leftForLtr(x, _itemWidth) { + return x; + }, + }; +}; +function getRtlAdapter(rtl, rectX, width) { + return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter(); +} +function overrideTextDirection(ctx, direction) { + let style, original; + if (direction === 'ltr' || direction === 'rtl') { + style = ctx.canvas.style; + original = [ + style.getPropertyValue('direction'), + style.getPropertyPriority('direction'), + ]; + style.setProperty('direction', direction, 'important'); + ctx.prevTextDirection = original; + } +} +function restoreTextDirection(ctx, original) { + if (original !== undefined) { + delete ctx.prevTextDirection; + ctx.canvas.style.setProperty('direction', original[0], original[1]); + } +} + +function propertyFn(property) { + if (property === 'angle') { return { - lo: lo, - hi: hi + between: _angleBetween, + compare: _angleDiff, + normalize: _normalizeAngle, }; } - const _lookupByKey = function _lookupByKey(table, key, value) { - return _lookup(table, value, function (index) { - return table[index][key] < value; - }); + return { + between: _isBetween, + compare: (a, b) => a - b, + normalize: x => x }; - const _rlookupByKey = function _rlookupByKey(table, key, value) { - return _lookup(table, value, function (index) { - return table[index][key] >= value; - }); +} +function normalizeSegment({start, end, count, loop, style}) { + return { + start: start % count, + end: end % count, + loop: loop && (end - start + 1) % count === 0, + style }; - function _filterBetween(values, min, max) { - let start = 0; - let end = values.length; - while (start < end && values[start] < min) { - start++; - } - while (end > start && values[end - 1] > max) { +} +function getSegment(segment, points, bounds) { + const {property, start: startBound, end: endBound} = bounds; + const {between, normalize} = propertyFn(property); + const count = points.length; + let {start, end, loop} = segment; + let i, ilen; + if (loop) { + start += count; + end += count; + for (i = 0, ilen = count; i < ilen; ++i) { + if (!between(normalize(points[start % count][property]), startBound, endBound)) { + break; + } + start--; end--; } - return start > 0 || end < values.length ? values.slice(start, end) : values; + start %= count; + end %= count; } - const arrayEvents = ['push', 'pop', 'shift', 'splice', 'unshift']; - function listenArrayEvents(array, listener) { - if (array._chartjs) { - array._chartjs.listeners.push(listener); - return; + if (end < start) { + end += count; + } + return {start, end, loop, style: segment.style}; +} +function _boundSegment(segment, points, bounds) { + if (!bounds) { + return [segment]; + } + const {property, start: startBound, end: endBound} = bounds; + const count = points.length; + const {compare, between, normalize} = propertyFn(property); + const {start, end, loop, style} = getSegment(segment, points, bounds); + const result = []; + let inside = false; + let subStart = null; + let value, point, prevValue; + const startIsBefore = () => between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0; + const endIsBefore = () => compare(endBound, value) === 0 || between(endBound, prevValue, value); + const shouldStart = () => inside || startIsBefore(); + const shouldStop = () => !inside || endIsBefore(); + for (let i = start, prev = start; i <= end; ++i) { + point = points[i % count]; + if (point.skip) { + continue; + } + value = normalize(point[property]); + if (value === prevValue) { + continue; + } + inside = between(value, startBound, endBound); + if (subStart === null && shouldStart()) { + subStart = compare(value, startBound) === 0 ? i : prev; + } + if (subStart !== null && shouldStop()) { + result.push(normalizeSegment({start: subStart, end: i, loop, count, style})); + subStart = null; + } + prev = i; + prevValue = value; + } + if (subStart !== null) { + result.push(normalizeSegment({start: subStart, end, loop, count, style})); + } + return result; +} +function _boundSegments(line, bounds) { + const result = []; + const segments = line.segments; + for (let i = 0; i < segments.length; i++) { + const sub = _boundSegment(segments[i], line.points, bounds); + if (sub.length) { + result.push(...sub); + } + } + return result; +} +function findStartAndEnd(points, count, loop, spanGaps) { + let start = 0; + let end = count - 1; + if (loop && !spanGaps) { + while (start < count && !points[start].skip) { + start++; } - Object.defineProperty(array, '_chartjs', { - configurable: true, - enumerable: false, - value: { - listeners: [listener] + } + while (start < count && points[start].skip) { + start++; + } + start %= count; + if (loop) { + end += start; + } + while (end > start && points[end % count].skip) { + end--; + } + end %= count; + return {start, end}; +} +function solidSegments(points, start, max, loop) { + const count = points.length; + const result = []; + let last = start; + let prev = points[start]; + let end; + for (end = start + 1; end <= max; ++end) { + const cur = points[end % count]; + if (cur.skip || cur.stop) { + if (!prev.skip) { + loop = false; + result.push({start: start % count, end: (end - 1) % count, loop}); + start = last = cur.stop ? end : null; } - }); - arrayEvents.forEach(function (key) { - const method = '_onData' + _capitalize(key); - const base = array[key]; - Object.defineProperty(array, key, { - configurable: true, - enumerable: false, - value: function value() { - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - const res = base.apply(this, args); - array._chartjs.listeners.forEach(function (object) { - if (typeof object[method] === 'function') { - object[method].apply(object, args); - } - }); - return res; - } - }); - }); + } else { + last = end; + if (prev.skip) { + start = end; + } + } + prev = cur; + } + if (last !== null) { + result.push({start: start % count, end: last % count, loop}); + } + return result; +} +function _computeSegments(line, segmentOptions) { + const points = line.points; + const spanGaps = line.options.spanGaps; + const count = points.length; + if (!count) { + return []; + } + const loop = !!line._loop; + const {start, end} = findStartAndEnd(points, count, loop, spanGaps); + if (spanGaps === true) { + return splitByStyles(line, [{start, end, loop}], points, segmentOptions); + } + const max = end < start ? end + count : end; + const completeLoop = !!line._fullLoop && start === 0 && end === count - 1; + return splitByStyles(line, solidSegments(points, start, max, completeLoop), points, segmentOptions); +} +function splitByStyles(line, segments, points, segmentOptions) { + if (!segmentOptions || !segmentOptions.setContext || !points) { + return segments; + } + return doSplitByStyles(line, segments, points, segmentOptions); +} +function doSplitByStyles(line, segments, points, segmentOptions) { + const chartContext = line._chart.getContext(); + const baseStyle = readStyle(line.options); + const {_datasetIndex: datasetIndex, options: {spanGaps}} = line; + const count = points.length; + const result = []; + let prevStyle = baseStyle; + let start = segments[0].start; + let i = start; + function addStyle(s, e, l, st) { + const dir = spanGaps ? -1 : 1; + if (s === e) { + return; + } + s += count; + while (points[s % count].skip) { + s -= dir; + } + while (points[e % count].skip) { + e += dir; + } + if (s % count !== e % count) { + result.push({start: s % count, end: e % count, loop: l, style: st}); + prevStyle = st; + start = e % count; + } + } + for (const segment of segments) { + start = spanGaps ? start : segment.start; + let prev = points[start % count]; + let style; + for (i = start + 1; i <= segment.end; i++) { + const pt = points[i % count]; + style = readStyle(segmentOptions.setContext(createContext(chartContext, { + type: 'segment', + p0: prev, + p1: pt, + p0DataIndex: (i - 1) % count, + p1DataIndex: i % count, + datasetIndex + }))); + if (styleChanged(style, prevStyle)) { + addStyle(start, i - 1, segment.loop, prevStyle); + } + prev = pt; + prevStyle = style; + } + if (start < i - 1) { + addStyle(start, i - 1, segment.loop, prevStyle); + } + } + return result; +} +function readStyle(options) { + return { + backgroundColor: options.backgroundColor, + borderCapStyle: options.borderCapStyle, + borderDash: options.borderDash, + borderDashOffset: options.borderDashOffset, + borderJoinStyle: options.borderJoinStyle, + borderWidth: options.borderWidth, + borderColor: options.borderColor + }; +} +function styleChanged(style, prevStyle) { + return prevStyle && JSON.stringify(style) !== JSON.stringify(prevStyle); +} + +var helpers = /*#__PURE__*/Object.freeze({ +__proto__: null, +easingEffects: effects, +isPatternOrGradient: isPatternOrGradient, +color: color, +getHoverColor: getHoverColor, +noop: noop, +uid: uid, +isNullOrUndef: isNullOrUndef, +isArray: isArray, +isObject: isObject, +isFinite: isNumberFinite, +finiteOrDefault: finiteOrDefault, +valueOrDefault: valueOrDefault, +toPercentage: toPercentage, +toDimension: toDimension, +callback: callback, +each: each, +_elementsEqual: _elementsEqual, +clone: clone$1, +_merger: _merger, +merge: merge, +mergeIf: mergeIf, +_mergerIf: _mergerIf, +_deprecated: _deprecated, +resolveObjectKey: resolveObjectKey, +_splitKey: _splitKey, +_capitalize: _capitalize, +defined: defined, +isFunction: isFunction, +setsEqual: setsEqual, +_isClickEvent: _isClickEvent, +toFontString: toFontString, +_measureText: _measureText, +_longestText: _longestText, +_alignPixel: _alignPixel, +clearCanvas: clearCanvas, +drawPoint: drawPoint, +drawPointLegend: drawPointLegend, +_isPointInArea: _isPointInArea, +clipArea: clipArea, +unclipArea: unclipArea, +_steppedLineTo: _steppedLineTo, +_bezierCurveTo: _bezierCurveTo, +renderText: renderText, +addRoundedRectPath: addRoundedRectPath, +_lookup: _lookup, +_lookupByKey: _lookupByKey, +_rlookupByKey: _rlookupByKey, +_filterBetween: _filterBetween, +listenArrayEvents: listenArrayEvents, +unlistenArrayEvents: unlistenArrayEvents, +_arrayUnique: _arrayUnique, +_createResolver: _createResolver, +_attachContext: _attachContext, +_descriptors: _descriptors, +_parseObjectDataRadialScale: _parseObjectDataRadialScale, +splineCurve: splineCurve, +splineCurveMonotone: splineCurveMonotone, +_updateBezierControlPoints: _updateBezierControlPoints, +_isDomSupported: _isDomSupported, +_getParentNode: _getParentNode, +getStyle: getStyle, +getRelativePosition: getRelativePosition, +getMaximumSize: getMaximumSize, +retinaScale: retinaScale, +supportsEventListenerOptions: supportsEventListenerOptions, +readUsedSize: readUsedSize, +fontString: fontString, +requestAnimFrame: requestAnimFrame, +throttled: throttled, +debounce: debounce, +_toLeftRightCenter: _toLeftRightCenter, +_alignStartEnd: _alignStartEnd, +_textX: _textX, +_getStartAndCountOfVisiblePoints: _getStartAndCountOfVisiblePoints, +_scaleRangesChanged: _scaleRangesChanged, +_pointInLine: _pointInLine, +_steppedInterpolation: _steppedInterpolation, +_bezierInterpolation: _bezierInterpolation, +formatNumber: formatNumber, +toLineHeight: toLineHeight, +_readValueToProps: _readValueToProps, +toTRBL: toTRBL, +toTRBLCorners: toTRBLCorners, +toPadding: toPadding, +toFont: toFont, +resolve: resolve, +_addGrace: _addGrace, +createContext: createContext, +PI: PI, +TAU: TAU, +PITAU: PITAU, +INFINITY: INFINITY, +RAD_PER_DEG: RAD_PER_DEG, +HALF_PI: HALF_PI, +QUARTER_PI: QUARTER_PI, +TWO_THIRDS_PI: TWO_THIRDS_PI, +log10: log10, +sign: sign, +niceNum: niceNum, +_factorize: _factorize, +isNumber: isNumber, +almostEquals: almostEquals, +almostWhole: almostWhole, +_setMinAndMaxByKey: _setMinAndMaxByKey, +toRadians: toRadians, +toDegrees: toDegrees, +_decimalPlaces: _decimalPlaces, +getAngleFromPoint: getAngleFromPoint, +distanceBetweenPoints: distanceBetweenPoints, +_angleDiff: _angleDiff, +_normalizeAngle: _normalizeAngle, +_angleBetween: _angleBetween, +_limitValue: _limitValue, +_int16Range: _int16Range, +_isBetween: _isBetween, +getRtlAdapter: getRtlAdapter, +overrideTextDirection: overrideTextDirection, +restoreTextDirection: restoreTextDirection, +_boundSegment: _boundSegment, +_boundSegments: _boundSegments, +_computeSegments: _computeSegments +}); + +function binarySearch(metaset, axis, value, intersect) { + const {controller, data, _sorted} = metaset; + const iScale = controller._cachedMeta.iScale; + if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) { + const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey; + if (!intersect) { + return lookupMethod(data, axis, value); + } else if (controller._sharedOptions) { + const el = data[0]; + const range = typeof el.getRange === 'function' && el.getRange(axis); + if (range) { + const start = lookupMethod(data, axis, value - range); + const end = lookupMethod(data, axis, value + range); + return {lo: start.lo, hi: end.hi}; + } + } + } + return {lo: 0, hi: data.length - 1}; +} +function evaluateInteractionItems(chart, axis, position, handler, intersect) { + const metasets = chart.getSortedVisibleDatasetMetas(); + const value = position[axis]; + for (let i = 0, ilen = metasets.length; i < ilen; ++i) { + const {index, data} = metasets[i]; + const {lo, hi} = binarySearch(metasets[i], axis, value, intersect); + for (let j = lo; j <= hi; ++j) { + const element = data[j]; + if (!element.skip) { + handler(element, index, j); + } + } + } +} +function getDistanceMetricForAxis(axis) { + const useX = axis.indexOf('x') !== -1; + const useY = axis.indexOf('y') !== -1; + return function(pt1, pt2) { + const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0; + const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0; + return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2)); + }; +} +function getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) { + const items = []; + if (!includeInvisible && !chart.isPointInArea(position)) { + return items; } - function unlistenArrayEvents(array, listener) { - const stub = array._chartjs; - if (!stub) { + const evaluationFunc = function(element, datasetIndex, index) { + if (!includeInvisible && !_isPointInArea(element, chart.chartArea, 0)) { return; } - const listeners = stub.listeners; - const index = listeners.indexOf(listener); - if (index !== -1) { - listeners.splice(index, 1); + if (element.inRange(position.x, position.y, useFinalPosition)) { + items.push({element, datasetIndex, index}); } - if (listeners.length > 0) { + }; + evaluateInteractionItems(chart, axis, position, evaluationFunc, true); + return items; +} +function getNearestRadialItems(chart, position, axis, useFinalPosition) { + let items = []; + function evaluationFunc(element, datasetIndex, index) { + const {startAngle, endAngle} = element.getProps(['startAngle', 'endAngle'], useFinalPosition); + const {angle} = getAngleFromPoint(element, {x: position.x, y: position.y}); + if (_angleBetween(angle, startAngle, endAngle)) { + items.push({element, datasetIndex, index}); + } + } + evaluateInteractionItems(chart, axis, position, evaluationFunc); + return items; +} +function getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) { + let items = []; + const distanceMetric = getDistanceMetricForAxis(axis); + let minDistance = Number.POSITIVE_INFINITY; + function evaluationFunc(element, datasetIndex, index) { + const inRange = element.inRange(position.x, position.y, useFinalPosition); + if (intersect && !inRange) { return; } - arrayEvents.forEach(function (key) { - delete array[key]; - }); - delete array._chartjs; - } - function _arrayUnique(items) { - const set = new Set(); - let i, ilen; - for (i = 0, ilen = items.length; i < ilen; ++i) { - set.add(items[i]); + const center = element.getCenterPoint(useFinalPosition); + const pointInArea = !!includeInvisible || chart.isPointInArea(center); + if (!pointInArea && !inRange) { + return; + } + const distance = distanceMetric(position, center); + if (distance < minDistance) { + items = [{element, datasetIndex, index}]; + minDistance = distance; + } else if (distance === minDistance) { + items.push({element, datasetIndex, index}); + } + } + evaluateInteractionItems(chart, axis, position, evaluationFunc); + return items; +} +function getNearestItems(chart, position, axis, intersect, useFinalPosition, includeInvisible) { + if (!includeInvisible && !chart.isPointInArea(position)) { + return []; + } + return axis === 'r' && !intersect + ? getNearestRadialItems(chart, position, axis, useFinalPosition) + : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition, includeInvisible); +} +function getAxisItems(chart, position, axis, intersect, useFinalPosition) { + const items = []; + const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange'; + let intersectsItem = false; + evaluateInteractionItems(chart, axis, position, (element, datasetIndex, index) => { + if (element[rangeMethod](position[axis], useFinalPosition)) { + items.push({element, datasetIndex, index}); + intersectsItem = intersectsItem || element.inRange(position.x, position.y, useFinalPosition); } - if (set.size === ilen) { + }); + if (intersect && !intersectsItem) { + return []; + } + return items; +} +var Interaction = { + evaluateInteractionItems, + modes: { + index(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const axis = options.axis || 'x'; + const includeInvisible = options.includeInvisible || false; + const items = options.intersect + ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) + : getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible); + const elements = []; + if (!items.length) { + return []; + } + chart.getSortedVisibleDatasetMetas().forEach((meta) => { + const index = items[0].index; + const element = meta.data[index]; + if (element && !element.skip) { + elements.push({element, datasetIndex: meta.index, index}); + } + }); + return elements; + }, + dataset(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const axis = options.axis || 'xy'; + const includeInvisible = options.includeInvisible || false; + let items = options.intersect + ? getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible) : + getNearestItems(chart, position, axis, false, useFinalPosition, includeInvisible); + if (items.length > 0) { + const datasetIndex = items[0].datasetIndex; + const data = chart.getDatasetMeta(datasetIndex).data; + items = []; + for (let i = 0; i < data.length; ++i) { + items.push({element: data[i], datasetIndex, index: i}); + } + } return items; + }, + point(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const axis = options.axis || 'xy'; + const includeInvisible = options.includeInvisible || false; + return getIntersectItems(chart, position, axis, useFinalPosition, includeInvisible); + }, + nearest(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + const axis = options.axis || 'xy'; + const includeInvisible = options.includeInvisible || false; + return getNearestItems(chart, position, axis, options.intersect, useFinalPosition, includeInvisible); + }, + x(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + return getAxisItems(chart, position, 'x', options.intersect, useFinalPosition); + }, + y(chart, e, options, useFinalPosition) { + const position = getRelativePosition(e, chart); + return getAxisItems(chart, position, 'y', options.intersect, useFinalPosition); } - const result = []; - set.forEach(function (item) { - result.push(item); - }); - return result; } +}; - function _getParentNode(domNode) { - let parent = domNode.parentNode; - if (parent && parent.toString() === '[object ShadowRoot]') { - parent = parent.host; - } - return parent; +const STATIC_POSITIONS = ['left', 'top', 'right', 'bottom']; +function filterByPosition(array, position) { + return array.filter(v => v.pos === position); +} +function filterDynamicPositionByAxis(array, axis) { + return array.filter(v => STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis); +} +function sortByWeight(array, reverse) { + return array.sort((a, b) => { + const v0 = reverse ? b : a; + const v1 = reverse ? a : b; + return v0.weight === v1.weight ? + v0.index - v1.index : + v0.weight - v1.weight; + }); +} +function wrapBoxes(boxes) { + const layoutBoxes = []; + let i, ilen, box, pos, stack, stackWeight; + for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) { + box = boxes[i]; + ({position: pos, options: {stack, stackWeight = 1}} = box); + layoutBoxes.push({ + index: i, + box, + pos, + horizontal: box.isHorizontal(), + weight: box.weight, + stack: stack && (pos + stack), + stackWeight + }); } - function parseMaxStyle(styleValue, node, parentProperty) { - let valueInPixels; - if (typeof styleValue === 'string') { - valueInPixels = parseInt(styleValue, 10); - if (styleValue.indexOf('%') !== -1) { - valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty]; - } + return layoutBoxes; +} +function buildStacks(layouts) { + const stacks = {}; + for (const wrap of layouts) { + const {stack, pos, stackWeight} = wrap; + if (!stack || !STATIC_POSITIONS.includes(pos)) { + continue; + } + const _stack = stacks[stack] || (stacks[stack] = {count: 0, placed: 0, weight: 0, size: 0}); + _stack.count++; + _stack.weight += stackWeight; + } + return stacks; +} +function setLayoutDims(layouts, params) { + const stacks = buildStacks(layouts); + const {vBoxMaxWidth, hBoxMaxHeight} = params; + let i, ilen, layout; + for (i = 0, ilen = layouts.length; i < ilen; ++i) { + layout = layouts[i]; + const {fullSize} = layout.box; + const stack = stacks[layout.stack]; + const factor = stack && layout.stackWeight / stack.weight; + if (layout.horizontal) { + layout.width = factor ? factor * vBoxMaxWidth : fullSize && params.availableWidth; + layout.height = hBoxMaxHeight; } else { - valueInPixels = styleValue; - } - return valueInPixels; - } - const getComputedStyle = function getComputedStyle(element) { - return window.getComputedStyle(element, null); + layout.width = vBoxMaxWidth; + layout.height = factor ? factor * hBoxMaxHeight : fullSize && params.availableHeight; + } + } + return stacks; +} +function buildLayoutBoxes(boxes) { + const layoutBoxes = wrapBoxes(boxes); + const fullSize = sortByWeight(layoutBoxes.filter(wrap => wrap.box.fullSize), true); + const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true); + const right = sortByWeight(filterByPosition(layoutBoxes, 'right')); + const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true); + const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom')); + const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x'); + const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y'); + return { + fullSize, + leftAndTop: left.concat(top), + rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal), + chartArea: filterByPosition(layoutBoxes, 'chartArea'), + vertical: left.concat(right).concat(centerVertical), + horizontal: top.concat(bottom).concat(centerHorizontal) }; - function getStyle(el, property) { - return el.currentStyle ? el.currentStyle[property] : getComputedStyle(el).getPropertyValue(property); - } - const positions = ['top', 'right', 'bottom', 'left']; - function getPositionedStyle(styles, style, suffix) { - const result = {}; - suffix = suffix ? '-' + suffix : ''; - for (let i = 0; i < 4; i++) { - const pos = positions[i]; - result[pos] = parseFloat(styles[style + '-' + pos + suffix]) || 0; - } - result.width = result.left + result.right; - result.height = result.top + result.bottom; - return result; - } - function getCanvasPosition(evt, canvas) { - const e = evt.originalEvent || evt; - const touches = e.touches; - const source = touches && touches.length ? touches[0] : e; - const offsetX = source.offsetX, - offsetY = source.offsetY; - let box = false; - let x, y; - if (offsetX > 0 || offsetY > 0) { - x = offsetX; - y = offsetY; +} +function getCombinedMax(maxPadding, chartArea, a, b) { + return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]); +} +function updateMaxPadding(maxPadding, boxPadding) { + maxPadding.top = Math.max(maxPadding.top, boxPadding.top); + maxPadding.left = Math.max(maxPadding.left, boxPadding.left); + maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom); + maxPadding.right = Math.max(maxPadding.right, boxPadding.right); +} +function updateDims(chartArea, params, layout, stacks) { + const {pos, box} = layout; + const maxPadding = chartArea.maxPadding; + if (!isObject(pos)) { + if (layout.size) { + chartArea[pos] -= layout.size; + } + const stack = stacks[layout.stack] || {size: 0, count: 1}; + stack.size = Math.max(stack.size, layout.horizontal ? box.height : box.width); + layout.size = stack.size / stack.count; + chartArea[pos] += layout.size; + } + if (box.getPadding) { + updateMaxPadding(maxPadding, box.getPadding()); + } + const newWidth = Math.max(0, params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right')); + const newHeight = Math.max(0, params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom')); + const widthChanged = newWidth !== chartArea.w; + const heightChanged = newHeight !== chartArea.h; + chartArea.w = newWidth; + chartArea.h = newHeight; + return layout.horizontal + ? {same: widthChanged, other: heightChanged} + : {same: heightChanged, other: widthChanged}; +} +function handleMaxPadding(chartArea) { + const maxPadding = chartArea.maxPadding; + function updatePos(pos) { + const change = Math.max(maxPadding[pos] - chartArea[pos], 0); + chartArea[pos] += change; + return change; + } + chartArea.y += updatePos('top'); + chartArea.x += updatePos('left'); + updatePos('right'); + updatePos('bottom'); +} +function getMargins(horizontal, chartArea) { + const maxPadding = chartArea.maxPadding; + function marginForPositions(positions) { + const margin = {left: 0, top: 0, right: 0, bottom: 0}; + positions.forEach((pos) => { + margin[pos] = Math.max(chartArea[pos], maxPadding[pos]); + }); + return margin; + } + return horizontal + ? marginForPositions(['left', 'right']) + : marginForPositions(['top', 'bottom']); +} +function fitBoxes(boxes, chartArea, params, stacks) { + const refitBoxes = []; + let i, ilen, layout, box, refit, changed; + for (i = 0, ilen = boxes.length, refit = 0; i < ilen; ++i) { + layout = boxes[i]; + box = layout.box; + box.update( + layout.width || chartArea.w, + layout.height || chartArea.h, + getMargins(layout.horizontal, chartArea) + ); + const {same, other} = updateDims(chartArea, params, layout, stacks); + refit |= same && refitBoxes.length; + changed = changed || other; + if (!box.fullSize) { + refitBoxes.push(layout); + } + } + return refit && fitBoxes(refitBoxes, chartArea, params, stacks) || changed; +} +function setBoxDims(box, left, top, width, height) { + box.top = top; + box.left = left; + box.right = left + width; + box.bottom = top + height; + box.width = width; + box.height = height; +} +function placeBoxes(boxes, chartArea, params, stacks) { + const userPadding = params.padding; + let {x, y} = chartArea; + for (const layout of boxes) { + const box = layout.box; + const stack = stacks[layout.stack] || {count: 1, placed: 0, weight: 1}; + const weight = (layout.stackWeight / stack.weight) || 1; + if (layout.horizontal) { + const width = chartArea.w * weight; + const height = stack.size || box.height; + if (defined(stack.start)) { + y = stack.start; + } + if (box.fullSize) { + setBoxDims(box, userPadding.left, y, params.outerWidth - userPadding.right - userPadding.left, height); + } else { + setBoxDims(box, chartArea.left + stack.placed, y, width, height); + } + stack.start = y; + stack.placed += width; + y = box.bottom; } else { - const rect = canvas.getBoundingClientRect(); - x = source.clientX - rect.left; - y = source.clientY - rect.top; - box = true; - } - return { - x: x, - y: y, - box: box + const height = chartArea.h * weight; + const width = stack.size || box.width; + if (defined(stack.start)) { + x = stack.start; + } + if (box.fullSize) { + setBoxDims(box, x, userPadding.top, width, params.outerHeight - userPadding.bottom - userPadding.top); + } else { + setBoxDims(box, x, chartArea.top + stack.placed, width, height); + } + stack.start = x; + stack.placed += height; + x = box.right; + } + } + chartArea.x = x; + chartArea.y = y; +} +defaults.set('layout', { + autoPadding: true, + padding: { + top: 0, + right: 0, + bottom: 0, + left: 0 + } +}); +var layouts = { + addBox(chart, item) { + if (!chart.boxes) { + chart.boxes = []; + } + item.fullSize = item.fullSize || false; + item.position = item.position || 'top'; + item.weight = item.weight || 0; + item._layers = item._layers || function() { + return [{ + z: 0, + draw(chartArea) { + item.draw(chartArea); + } + }]; }; - } - function getRelativePosition(evt, chart) { - const canvas = chart.canvas, - currentDevicePixelRatio = chart.currentDevicePixelRatio; - const style = getComputedStyle(canvas); - const borderBox = style.boxSizing === 'border-box'; - const paddings = getPositionedStyle(style, 'padding'); - const borders = getPositionedStyle(style, 'border', 'width'); - const _getCanvasPosition = getCanvasPosition(evt, canvas), - x = _getCanvasPosition.x, - y = _getCanvasPosition.y, - box = _getCanvasPosition.box; - const xOffset = paddings.left + (box && borders.left); - const yOffset = paddings.top + (box && borders.top); - let width = chart.width, - height = chart.height; - if (borderBox) { - width -= paddings.width + borders.width; - height -= paddings.height + borders.height; + chart.boxes.push(item); + }, + removeBox(chart, layoutItem) { + const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1; + if (index !== -1) { + chart.boxes.splice(index, 1); + } + }, + configure(chart, item, options) { + item.fullSize = options.fullSize; + item.position = options.position; + item.weight = options.weight; + }, + update(chart, width, height, minPadding) { + if (!chart) { + return; } - return { - x: Math.round((x - xOffset) / width * canvas.width / currentDevicePixelRatio), - y: Math.round((y - yOffset) / height * canvas.height / currentDevicePixelRatio) - }; - } - function getContainerSize(canvas, width, height) { - let maxWidth, maxHeight; - if (width === undefined || height === undefined) { - const container = _getParentNode(canvas); - if (!container) { - width = canvas.clientWidth; - height = canvas.clientHeight; - } else { - const rect = container.getBoundingClientRect(); - const containerStyle = getComputedStyle(container); - const containerBorder = getPositionedStyle(containerStyle, 'border', 'width'); - const containerPadding = getPositionedStyle(containerStyle, 'padding'); - width = rect.width - containerPadding.width - containerBorder.width; - height = rect.height - containerPadding.height - containerBorder.height; - maxWidth = parseMaxStyle(containerStyle.maxWidth, container, 'clientWidth'); - maxHeight = parseMaxStyle(containerStyle.maxHeight, container, 'clientHeight'); + const padding = toPadding(chart.options.layout.padding); + const availableWidth = Math.max(width - padding.width, 0); + const availableHeight = Math.max(height - padding.height, 0); + const boxes = buildLayoutBoxes(chart.boxes); + const verticalBoxes = boxes.vertical; + const horizontalBoxes = boxes.horizontal; + each(chart.boxes, box => { + if (typeof box.beforeLayout === 'function') { + box.beforeLayout(); } - } - return { - width: width, - height: height, - maxWidth: maxWidth || INFINITY, - maxHeight: maxHeight || INFINITY - }; + }); + const visibleVerticalBoxCount = verticalBoxes.reduce((total, wrap) => + wrap.box.options && wrap.box.options.display === false ? total : total + 1, 0) || 1; + const params = Object.freeze({ + outerWidth: width, + outerHeight: height, + padding, + availableWidth, + availableHeight, + vBoxMaxWidth: availableWidth / 2 / visibleVerticalBoxCount, + hBoxMaxHeight: availableHeight / 2 + }); + const maxPadding = Object.assign({}, padding); + updateMaxPadding(maxPadding, toPadding(minPadding)); + const chartArea = Object.assign({ + maxPadding, + w: availableWidth, + h: availableHeight, + x: padding.left, + y: padding.top + }, padding); + const stacks = setLayoutDims(verticalBoxes.concat(horizontalBoxes), params); + fitBoxes(boxes.fullSize, chartArea, params, stacks); + fitBoxes(verticalBoxes, chartArea, params, stacks); + if (fitBoxes(horizontalBoxes, chartArea, params, stacks)) { + fitBoxes(verticalBoxes, chartArea, params, stacks); + } + handleMaxPadding(chartArea); + placeBoxes(boxes.leftAndTop, chartArea, params, stacks); + chartArea.x += chartArea.w; + chartArea.y += chartArea.h; + placeBoxes(boxes.rightAndBottom, chartArea, params, stacks); + chart.chartArea = { + left: chartArea.left, + top: chartArea.top, + right: chartArea.left + chartArea.w, + bottom: chartArea.top + chartArea.h, + height: chartArea.h, + width: chartArea.w, + }; + each(boxes.chartArea, (layout) => { + const box = layout.box; + Object.assign(box, chart.chartArea); + box.update(chartArea.w, chartArea.h, {left: 0, top: 0, right: 0, bottom: 0}); + }); + } +}; + +class BasePlatform { + acquireContext(canvas, aspectRatio) {} + releaseContext(context) { + return false; + } + addEventListener(chart, type, listener) {} + removeEventListener(chart, type, listener) {} + getDevicePixelRatio() { + return 1; } - function getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) { - const style = getComputedStyle(canvas); - const margins = getPositionedStyle(style, 'margin'); - const maxWidth = parseMaxStyle(style.maxWidth, canvas, 'clientWidth') || INFINITY; - const maxHeight = parseMaxStyle(style.maxHeight, canvas, 'clientHeight') || INFINITY; - const containerSize = getContainerSize(canvas, bbWidth, bbHeight); - let width = containerSize.width, - height = containerSize.height; - if (style.boxSizing === 'content-box') { - const borders = getPositionedStyle(style, 'border', 'width'); - const paddings = getPositionedStyle(style, 'padding'); - width -= paddings.width + borders.width; - height -= paddings.height + borders.height; - } - width = Math.max(0, width - margins.width); - height = Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height - margins.height); + getMaximumSize(element, width, height, aspectRatio) { + width = Math.max(0, width || element.width); + height = height || element.height; return { - width: Math.min(width, maxWidth, containerSize.maxWidth), - height: Math.min(height, maxHeight, containerSize.maxHeight) + width, + height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height) }; } - function retinaScale(chart, forceRatio) { - const pixelRatio = chart.currentDevicePixelRatio = forceRatio || typeof window !== 'undefined' && window.devicePixelRatio || 1; - const canvas = chart.canvas, - width = chart.width, - height = chart.height; - canvas.height = height * pixelRatio; - canvas.width = width * pixelRatio; - chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0); - if (canvas.style && !canvas.style.height && !canvas.style.width) { - canvas.style.height = height + 'px'; - canvas.style.width = width + 'px'; - } - } - const supportsEventListenerOptions = function () { - let passiveSupported = false; - try { - const options = { - get passive() { - passiveSupported = true; - return false; - } - }; - window.addEventListener('test', null, options); - window.removeEventListener('test', null, options); - } catch (e) { - } - return passiveSupported; - }(); - function readUsedSize(element, property) { - const value = getStyle(element, property); - const matches = value && value.match(/^(\d+)(\.\d+)?px$/); - return matches ? +matches[1] : undefined; + isAttached(canvas) { + return true; + } + updateConfig(config) { } +} - function getRelativePosition$1(e, chart) { - if ('native' in e) { - return { - x: e.x, - y: e.y - }; - } - return getRelativePosition(e, chart); +class BasicPlatform extends BasePlatform { + acquireContext(item) { + return item && item.getContext && item.getContext('2d') || null; } - function evaluateAllVisibleItems(chart, handler) { - const metasets = chart.getSortedVisibleDatasetMetas(); - let index, data, element; - for (let i = 0, ilen = metasets.length; i < ilen; ++i) { - const _metasets$i = metasets[i]; - index = _metasets$i.index; - data = _metasets$i.data; - for (let j = 0, jlen = data.length; j < jlen; ++j) { - element = data[j]; - if (!element.skip) { - handler(element, index, j); - } - } - } + updateConfig(config) { + config.options.animation = false; } - function binarySearch(metaset, axis, value, intersect) { - const controller = metaset.controller, - data = metaset.data, - _sorted = metaset._sorted; - const iScale = controller._cachedMeta.iScale; - if (iScale && axis === iScale.axis && _sorted && data.length) { - const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey; - if (!intersect) { - return lookupMethod(data, axis, value); - } else if (controller._sharedOptions) { - const el = data[0]; - const range = typeof el.getRange === 'function' && el.getRange(axis); - if (range) { - const start = lookupMethod(data, axis, value - range); - const end = lookupMethod(data, axis, value + range); - return { - lo: start.lo, - hi: end.hi - }; - } +} + +const EXPANDO_KEY = '$chartjs'; +const EVENT_TYPES = { + touchstart: 'mousedown', + touchmove: 'mousemove', + touchend: 'mouseup', + pointerenter: 'mouseenter', + pointerdown: 'mousedown', + pointermove: 'mousemove', + pointerup: 'mouseup', + pointerleave: 'mouseout', + pointerout: 'mouseout' +}; +const isNullOrEmpty = value => value === null || value === ''; +function initCanvas(canvas, aspectRatio) { + const style = canvas.style; + const renderHeight = canvas.getAttribute('height'); + const renderWidth = canvas.getAttribute('width'); + canvas[EXPANDO_KEY] = { + initial: { + height: renderHeight, + width: renderWidth, + style: { + display: style.display, + height: style.height, + width: style.width } } - return { - lo: 0, - hi: data.length - 1 - }; + }; + style.display = style.display || 'block'; + style.boxSizing = style.boxSizing || 'border-box'; + if (isNullOrEmpty(renderWidth)) { + const displayWidth = readUsedSize(canvas, 'width'); + if (displayWidth !== undefined) { + canvas.width = displayWidth; + } } - function optimizedEvaluateItems(chart, axis, position, handler, intersect) { - const metasets = chart.getSortedVisibleDatasetMetas(); - const value = position[axis]; - for (let i = 0, ilen = metasets.length; i < ilen; ++i) { - const _metasets$i2 = metasets[i], - index = _metasets$i2.index, - data = _metasets$i2.data; - const _binarySearch = binarySearch(metasets[i], axis, value, intersect), - lo = _binarySearch.lo, - hi = _binarySearch.hi; - for (let j = lo; j <= hi; ++j) { - const element = data[j]; - if (!element.skip) { - handler(element, index, j); - } - } + if (isNullOrEmpty(renderHeight)) { + if (canvas.style.height === '') { + canvas.height = canvas.width / (aspectRatio || 2); + } else { + const displayHeight = readUsedSize(canvas, 'height'); + if (displayHeight !== undefined) { + canvas.height = displayHeight; + } + } + } + return canvas; +} +const eventListenerOptions = supportsEventListenerOptions ? {passive: true} : false; +function addListener(node, type, listener) { + node.addEventListener(type, listener, eventListenerOptions); +} +function removeListener(chart, type, listener) { + chart.canvas.removeEventListener(type, listener, eventListenerOptions); +} +function fromNativeEvent(event, chart) { + const type = EVENT_TYPES[event.type] || event.type; + const {x, y} = getRelativePosition(event, chart); + return { + type, + chart, + native: event, + x: x !== undefined ? x : null, + y: y !== undefined ? y : null, + }; +} +function nodeListContains(nodeList, canvas) { + for (const node of nodeList) { + if (node === canvas || node.contains(canvas)) { + return true; } } - function getDistanceMetricForAxis(axis) { - const useX = axis.indexOf('x') !== -1; - const useY = axis.indexOf('y') !== -1; - return function (pt1, pt2) { - const deltaX = useX ? Math.abs(pt1.x - pt2.x) : 0; - const deltaY = useY ? Math.abs(pt1.y - pt2.y) : 0; - return Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2)); - }; +} +function createAttachObserver(chart, type, listener) { + const canvas = chart.canvas; + const observer = new MutationObserver(entries => { + let trigger = false; + for (const entry of entries) { + trigger = trigger || nodeListContains(entry.addedNodes, canvas); + trigger = trigger && !nodeListContains(entry.removedNodes, canvas); + } + if (trigger) { + listener(); + } + }); + observer.observe(document, {childList: true, subtree: true}); + return observer; +} +function createDetachObserver(chart, type, listener) { + const canvas = chart.canvas; + const observer = new MutationObserver(entries => { + let trigger = false; + for (const entry of entries) { + trigger = trigger || nodeListContains(entry.removedNodes, canvas); + trigger = trigger && !nodeListContains(entry.addedNodes, canvas); + } + if (trigger) { + listener(); + } + }); + observer.observe(document, {childList: true, subtree: true}); + return observer; +} +const drpListeningCharts = new Map(); +let oldDevicePixelRatio = 0; +function onWindowResize() { + const dpr = window.devicePixelRatio; + if (dpr === oldDevicePixelRatio) { + return; + } + oldDevicePixelRatio = dpr; + drpListeningCharts.forEach((resize, chart) => { + if (chart.currentDevicePixelRatio !== dpr) { + resize(); + } + }); +} +function listenDevicePixelRatioChanges(chart, resize) { + if (!drpListeningCharts.size) { + window.addEventListener('resize', onWindowResize); + } + drpListeningCharts.set(chart, resize); +} +function unlistenDevicePixelRatioChanges(chart) { + drpListeningCharts.delete(chart); + if (!drpListeningCharts.size) { + window.removeEventListener('resize', onWindowResize); + } +} +function createResizeObserver(chart, type, listener) { + const canvas = chart.canvas; + const container = canvas && _getParentNode(canvas); + if (!container) { + return; + } + const resize = throttled((width, height) => { + const w = container.clientWidth; + listener(width, height); + if (w < container.clientWidth) { + listener(); + } + }, window); + const observer = new ResizeObserver(entries => { + const entry = entries[0]; + const width = entry.contentRect.width; + const height = entry.contentRect.height; + if (width === 0 && height === 0) { + return; + } + resize(width, height); + }); + observer.observe(container); + listenDevicePixelRatioChanges(chart, resize); + return observer; +} +function releaseObserver(chart, type, observer) { + if (observer) { + observer.disconnect(); + } + if (type === 'resize') { + unlistenDevicePixelRatioChanges(chart); + } +} +function createProxyAndListen(chart, type, listener) { + const canvas = chart.canvas; + const proxy = throttled((event) => { + if (chart.ctx !== null) { + listener(fromNativeEvent(event, chart)); + } + }, chart, (args) => { + const event = args[0]; + return [event, event.offsetX, event.offsetY]; + }); + addListener(canvas, type, proxy); + return proxy; +} +class DomPlatform extends BasePlatform { + acquireContext(canvas, aspectRatio) { + const context = canvas && canvas.getContext && canvas.getContext('2d'); + if (context && context.canvas === canvas) { + initCanvas(canvas, aspectRatio); + return context; + } + return null; } - function getIntersectItems(chart, position, axis, useFinalPosition) { - const items = []; - if (!_isPointInArea(position, chart.chartArea)) { - return items; + releaseContext(context) { + const canvas = context.canvas; + if (!canvas[EXPANDO_KEY]) { + return false; } - const evaluationFunc = function evaluationFunc(element, datasetIndex, index) { - if (element.inRange(position.x, position.y, useFinalPosition)) { - items.push({ - element: element, - datasetIndex: datasetIndex, - index: index - }); + const initial = canvas[EXPANDO_KEY].initial; + ['height', 'width'].forEach((prop) => { + const value = initial[prop]; + if (isNullOrUndef(value)) { + canvas.removeAttribute(prop); + } else { + canvas.setAttribute(prop, value); } - }; - optimizedEvaluateItems(chart, axis, position, evaluationFunc, true); - return items; + }); + const style = initial.style || {}; + Object.keys(style).forEach((key) => { + canvas.style[key] = style[key]; + }); + canvas.width = canvas.width; + delete canvas[EXPANDO_KEY]; + return true; } - function getNearestItems(chart, position, axis, intersect, useFinalPosition) { - const distanceMetric = getDistanceMetricForAxis(axis); - let minDistance = Number.POSITIVE_INFINITY; - let items = []; - if (!_isPointInArea(position, chart.chartArea)) { - return items; + addEventListener(chart, type, listener) { + this.removeEventListener(chart, type); + const proxies = chart.$proxies || (chart.$proxies = {}); + const handlers = { + attach: createAttachObserver, + detach: createDetachObserver, + resize: createResizeObserver + }; + const handler = handlers[type] || createProxyAndListen; + proxies[type] = handler(chart, type, listener); + } + removeEventListener(chart, type) { + const proxies = chart.$proxies || (chart.$proxies = {}); + const proxy = proxies[type]; + if (!proxy) { + return; } - const evaluationFunc = function evaluationFunc(element, datasetIndex, index) { - if (intersect && !element.inRange(position.x, position.y, useFinalPosition)) { - return; - } - const center = element.getCenterPoint(useFinalPosition); - const distance = distanceMetric(position, center); - if (distance < minDistance) { - items = [{ - element: element, - datasetIndex: datasetIndex, - index: index - }]; - minDistance = distance; - } else if (distance === minDistance) { - items.push({ - element: element, - datasetIndex: datasetIndex, - index: index - }); - } + const handlers = { + attach: releaseObserver, + detach: releaseObserver, + resize: releaseObserver }; - optimizedEvaluateItems(chart, axis, position, evaluationFunc); - return items; + const handler = handlers[type] || removeListener; + handler(chart, type, proxy); + proxies[type] = undefined; } - function getAxisItems(chart, e, options, useFinalPosition) { - const position = getRelativePosition$1(e, chart); - const items = []; - const axis = options.axis; - const rangeMethod = axis === 'x' ? 'inXRange' : 'inYRange'; - let intersectsItem = false; - evaluateAllVisibleItems(chart, function (element, datasetIndex, index) { - if (element[rangeMethod](position[axis], useFinalPosition)) { - items.push({ - element: element, - datasetIndex: datasetIndex, - index: index - }); - } - if (element.inRange(position.x, position.y, useFinalPosition)) { - intersectsItem = true; - } - }); - if (options.intersect && !intersectsItem) { - return []; - } - return items; + getDevicePixelRatio() { + return window.devicePixelRatio; } - const Interaction = { - modes: { - index: function index(chart, e, options, useFinalPosition) { - const position = getRelativePosition$1(e, chart); - const axis = options.axis || 'x'; - const items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition) : getNearestItems(chart, position, axis, false, useFinalPosition); - const elements = []; - if (!items.length) { - return []; - } - chart.getSortedVisibleDatasetMetas().forEach(function (meta) { - const index = items[0].index; - const element = meta.data[index]; - if (element && !element.skip) { - elements.push({ - element: element, - datasetIndex: meta.index, - index: index - }); - } - }); - return elements; - }, - dataset: function dataset(chart, e, options, useFinalPosition) { - const position = getRelativePosition$1(e, chart); - const axis = options.axis || 'xy'; - let items = options.intersect ? getIntersectItems(chart, position, axis, useFinalPosition) : getNearestItems(chart, position, axis, false, useFinalPosition); - if (items.length > 0) { - const datasetIndex = items[0].datasetIndex; - const data = chart.getDatasetMeta(datasetIndex).data; - items = []; - for (let i = 0; i < data.length; ++i) { - items.push({ - element: data[i], - datasetIndex: datasetIndex, - index: i - }); - } - } - return items; + getMaximumSize(canvas, width, height, aspectRatio) { + return getMaximumSize(canvas, width, height, aspectRatio); + } + isAttached(canvas) { + const container = _getParentNode(canvas); + return !!(container && container.isConnected); + } +} + +function _detectPlatform(canvas) { + if (!_isDomSupported() || (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas)) { + return BasicPlatform; + } + return DomPlatform; +} + +var platforms = /*#__PURE__*/Object.freeze({ +__proto__: null, +_detectPlatform: _detectPlatform, +BasePlatform: BasePlatform, +BasicPlatform: BasicPlatform, +DomPlatform: DomPlatform +}); + +const transparent = 'transparent'; +const interpolators = { + boolean(from, to, factor) { + return factor > 0.5 ? to : from; + }, + color(from, to, factor) { + const c0 = color(from || transparent); + const c1 = c0.valid && color(to || transparent); + return c1 && c1.valid + ? c1.mix(c0, factor).hexString() + : to; + }, + number(from, to, factor) { + return from + (to - from) * factor; + } +}; +class Animation { + constructor(cfg, target, prop, to) { + const currentValue = target[prop]; + to = resolve([cfg.to, to, currentValue, cfg.from]); + const from = resolve([cfg.from, currentValue, to]); + this._active = true; + this._fn = cfg.fn || interpolators[cfg.type || typeof from]; + this._easing = effects[cfg.easing] || effects.linear; + this._start = Math.floor(Date.now() + (cfg.delay || 0)); + this._duration = this._total = Math.floor(cfg.duration); + this._loop = !!cfg.loop; + this._target = target; + this._prop = prop; + this._from = from; + this._to = to; + this._promises = undefined; + } + active() { + return this._active; + } + update(cfg, to, date) { + if (this._active) { + this._notify(false); + const currentValue = this._target[this._prop]; + const elapsed = date - this._start; + const remain = this._duration - elapsed; + this._start = date; + this._duration = Math.floor(Math.max(remain, cfg.duration)); + this._total += elapsed; + this._loop = !!cfg.loop; + this._to = resolve([cfg.to, to, currentValue, cfg.from]); + this._from = resolve([cfg.from, currentValue, to]); + } + } + cancel() { + if (this._active) { + this.tick(Date.now()); + this._active = false; + this._notify(false); + } + } + tick(date) { + const elapsed = date - this._start; + const duration = this._duration; + const prop = this._prop; + const from = this._from; + const loop = this._loop; + const to = this._to; + let factor; + this._active = from !== to && (loop || (elapsed < duration)); + if (!this._active) { + this._target[prop] = to; + this._notify(true); + return; + } + if (elapsed < 0) { + this._target[prop] = from; + return; + } + factor = (elapsed / duration) % 2; + factor = loop && factor > 1 ? 2 - factor : factor; + factor = this._easing(Math.min(1, Math.max(0, factor))); + this._target[prop] = this._fn(from, to, factor); + } + wait() { + const promises = this._promises || (this._promises = []); + return new Promise((res, rej) => { + promises.push({res, rej}); + }); + } + _notify(resolved) { + const method = resolved ? 'res' : 'rej'; + const promises = this._promises || []; + for (let i = 0; i < promises.length; i++) { + promises[i][method](); + } + } +} + +const numbers = ['x', 'y', 'borderWidth', 'radius', 'tension']; +const colors = ['color', 'borderColor', 'backgroundColor']; +defaults.set('animation', { + delay: undefined, + duration: 1000, + easing: 'easeOutQuart', + fn: undefined, + from: undefined, + loop: undefined, + to: undefined, + type: undefined, +}); +const animationOptions = Object.keys(defaults.animation); +defaults.describe('animation', { + _fallback: false, + _indexable: false, + _scriptable: (name) => name !== 'onProgress' && name !== 'onComplete' && name !== 'fn', +}); +defaults.set('animations', { + colors: { + type: 'color', + properties: colors + }, + numbers: { + type: 'number', + properties: numbers + }, +}); +defaults.describe('animations', { + _fallback: 'animation', +}); +defaults.set('transitions', { + active: { + animation: { + duration: 400 + } + }, + resize: { + animation: { + duration: 0 + } + }, + show: { + animations: { + colors: { + from: 'transparent' }, - point: function point(chart, e, options, useFinalPosition) { - const position = getRelativePosition$1(e, chart); - const axis = options.axis || 'xy'; - return getIntersectItems(chart, position, axis, useFinalPosition); + visible: { + type: 'boolean', + duration: 0 }, - nearest: function nearest(chart, e, options, useFinalPosition) { - const position = getRelativePosition$1(e, chart); - const axis = options.axis || 'xy'; - return getNearestItems(chart, position, axis, options.intersect, useFinalPosition); + } + }, + hide: { + animations: { + colors: { + to: 'transparent' }, - x: function x(chart, e, options, useFinalPosition) { - options.axis = 'x'; - return getAxisItems(chart, e, options, useFinalPosition); + visible: { + type: 'boolean', + easing: 'linear', + fn: v => v | 0 }, - y: function y(chart, e, options, useFinalPosition) { - options.axis = 'y'; - return getAxisItems(chart, e, options, useFinalPosition); - } - } - }; - - function toLineHeight(value, size) { - const matches = ('' + value).match(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/); - if (!matches || matches[1] === 'normal') { - return size * 1.2; - } - value = +matches[2]; - switch (matches[3]) { - case 'px': - return value; - case '%': - value /= 100; - break; } - return size * value; } - const numberOrZero = function numberOrZero(v) { - return +v || 0; - }; - function toTRBL(value) { - let t, r, b, l; - if (isObject(value)) { - t = numberOrZero(value.top); - r = numberOrZero(value.right); - b = numberOrZero(value.bottom); - l = numberOrZero(value.left); - } else { - t = r = b = l = numberOrZero(value); - } - return { - top: t, - right: r, - bottom: b, - left: l - }; +}); +class Animations { + constructor(chart, config) { + this._chart = chart; + this._properties = new Map(); + this.configure(config); } - function toTRBLCorners(value) { - let tl, tr, bl, br; - if (isObject(value)) { - tl = numberOrZero(value.topLeft); - tr = numberOrZero(value.topRight); - bl = numberOrZero(value.bottomLeft); - br = numberOrZero(value.bottomRight); - } else { - tl = tr = bl = br = numberOrZero(value); + configure(config) { + if (!isObject(config)) { + return; } - return { - topLeft: tl, - topRight: tr, - bottomLeft: bl, - bottomRight: br - }; - } - function toPadding(value) { - const obj = toTRBL(value); - obj.width = obj.left + obj.right; - obj.height = obj.top + obj.bottom; - return obj; + const animatedProps = this._properties; + Object.getOwnPropertyNames(config).forEach(key => { + const cfg = config[key]; + if (!isObject(cfg)) { + return; + } + const resolved = {}; + for (const option of animationOptions) { + resolved[option] = cfg[option]; + } + (isArray(cfg.properties) && cfg.properties || [key]).forEach((prop) => { + if (prop === key || !animatedProps.has(prop)) { + animatedProps.set(prop, resolved); + } + }); + }); } - function toFont(options, fallback) { - options = options || {}; - fallback = fallback || defaults.font; - let size = valueOrDefault(options.size, fallback.size); - if (typeof size === 'string') { - size = parseInt(size, 10); - } - const font = { - color: valueOrDefault(options.color, fallback.color), - family: valueOrDefault(options.family, fallback.family), - lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size), - lineWidth: valueOrDefault(options.lineWidth, fallback.lineWidth), - size: size, - style: valueOrDefault(options.style, fallback.style), - weight: valueOrDefault(options.weight, fallback.weight), - strokeStyle: valueOrDefault(options.strokeStyle, fallback.strokeStyle), - string: '' - }; - font.string = toFontString(font); - return font; + _animateOptions(target, values) { + const newOptions = values.options; + const options = resolveTargetOptions(target, newOptions); + if (!options) { + return []; + } + const animations = this._createAnimations(options, newOptions); + if (newOptions.$shared) { + awaitAll(target.options.$animations, newOptions).then(() => { + target.options = newOptions; + }, () => { + }); + } + return animations; } - function resolve(inputs, context, index, info) { - let cacheable = true; - let i, ilen, value; - for (i = 0, ilen = inputs.length; i < ilen; ++i) { - value = inputs[i]; - if (value === undefined) { + _createAnimations(target, values) { + const animatedProps = this._properties; + const animations = []; + const running = target.$animations || (target.$animations = {}); + const props = Object.keys(values); + const date = Date.now(); + let i; + for (i = props.length - 1; i >= 0; --i) { + const prop = props[i]; + if (prop.charAt(0) === '$') { continue; } - if (context !== undefined && typeof value === 'function') { - value = value(context); - cacheable = false; - } - if (index !== undefined && isArray(value)) { - value = value[index % value.length]; - cacheable = false; + if (prop === 'options') { + animations.push(...this._animateOptions(target, values)); + continue; } - if (value !== undefined) { - if (info && !cacheable) { - info.cacheable = false; + const value = values[prop]; + let animation = running[prop]; + const cfg = animatedProps.get(prop); + if (animation) { + if (cfg && animation.active()) { + animation.update(cfg, value, date); + continue; + } else { + animation.cancel(); } - return value; } + if (!cfg || !cfg.duration) { + target[prop] = value; + continue; + } + running[prop] = animation = new Animation(cfg, target, prop, value); + animations.push(animation); } + return animations; } - - const STATIC_POSITIONS = ['left', 'top', 'right', 'bottom']; - function filterByPosition(array, position) { - return array.filter(function (v) { - return v.pos === position; - }); - } - function filterDynamicPositionByAxis(array, axis) { - return array.filter(function (v) { - return STATIC_POSITIONS.indexOf(v.pos) === -1 && v.box.axis === axis; - }); - } - function sortByWeight(array, reverse) { - return array.sort(function (a, b) { - const v0 = reverse ? b : a; - const v1 = reverse ? a : b; - return v0.weight === v1.weight ? v0.index - v1.index : v0.weight - v1.weight; - }); - } - function wrapBoxes(boxes) { - const layoutBoxes = []; - let i, ilen, box; - for (i = 0, ilen = (boxes || []).length; i < ilen; ++i) { - box = boxes[i]; - layoutBoxes.push({ - index: i, - box: box, - pos: box.position, - horizontal: box.isHorizontal(), - weight: box.weight - }); + update(target, values) { + if (this._properties.size === 0) { + Object.assign(target, values); + return; + } + const animations = this._createAnimations(target, values); + if (animations.length) { + animator.add(this._chart, animations); + return true; } - return layoutBoxes; } - function setLayoutDims(layouts, params) { - let i, ilen, layout; - for (i = 0, ilen = layouts.length; i < ilen; ++i) { - layout = layouts[i]; - if (layout.horizontal) { - layout.width = layout.box.fullWidth && params.availableWidth; - layout.height = params.hBoxMaxHeight; - } else { - layout.width = params.vBoxMaxWidth; - layout.height = layout.box.fullWidth && params.availableHeight; - } +} +function awaitAll(animations, properties) { + const running = []; + const keys = Object.keys(properties); + for (let i = 0; i < keys.length; i++) { + const anim = animations[keys[i]]; + if (anim && anim.active()) { + running.push(anim.wait()); } } - function buildLayoutBoxes(boxes) { - const layoutBoxes = wrapBoxes(boxes); - const left = sortByWeight(filterByPosition(layoutBoxes, 'left'), true); - const right = sortByWeight(filterByPosition(layoutBoxes, 'right')); - const top = sortByWeight(filterByPosition(layoutBoxes, 'top'), true); - const bottom = sortByWeight(filterByPosition(layoutBoxes, 'bottom')); - const centerHorizontal = filterDynamicPositionByAxis(layoutBoxes, 'x'); - const centerVertical = filterDynamicPositionByAxis(layoutBoxes, 'y'); - return { - leftAndTop: left.concat(top), - rightAndBottom: right.concat(centerVertical).concat(bottom).concat(centerHorizontal), - chartArea: filterByPosition(layoutBoxes, 'chartArea'), - vertical: left.concat(right).concat(centerVertical), - horizontal: top.concat(bottom).concat(centerHorizontal) - }; + return Promise.all(running); +} +function resolveTargetOptions(target, newOptions) { + if (!newOptions) { + return; } - function getCombinedMax(maxPadding, chartArea, a, b) { - return Math.max(maxPadding[a], chartArea[a]) + Math.max(maxPadding[b], chartArea[b]); + let options = target.options; + if (!options) { + target.options = newOptions; + return; } - function updateDims(chartArea, params, layout) { - const box = layout.box; - const maxPadding = chartArea.maxPadding; - if (isObject(layout.pos)) { + if (options.$shared) { + target.options = options = Object.assign({}, options, {$shared: false, $animations: {}}); + } + return options; +} + +function scaleClip(scale, allowedOverflow) { + const opts = scale && scale.options || {}; + const reverse = opts.reverse; + const min = opts.min === undefined ? allowedOverflow : 0; + const max = opts.max === undefined ? allowedOverflow : 0; + return { + start: reverse ? max : min, + end: reverse ? min : max + }; +} +function defaultClip(xScale, yScale, allowedOverflow) { + if (allowedOverflow === false) { + return false; + } + const x = scaleClip(xScale, allowedOverflow); + const y = scaleClip(yScale, allowedOverflow); + return { + top: y.end, + right: x.end, + bottom: y.start, + left: x.start + }; +} +function toClip(value) { + let t, r, b, l; + if (isObject(value)) { + t = value.top; + r = value.right; + b = value.bottom; + l = value.left; + } else { + t = r = b = l = value; + } + return { + top: t, + right: r, + bottom: b, + left: l, + disabled: value === false + }; +} +function getSortedDatasetIndices(chart, filterVisible) { + const keys = []; + const metasets = chart._getSortedDatasetMetas(filterVisible); + let i, ilen; + for (i = 0, ilen = metasets.length; i < ilen; ++i) { + keys.push(metasets[i].index); + } + return keys; +} +function applyStack(stack, value, dsIndex, options = {}) { + const keys = stack.keys; + const singleMode = options.mode === 'single'; + let i, ilen, datasetIndex, otherValue; + if (value === null) { + return; + } + for (i = 0, ilen = keys.length; i < ilen; ++i) { + datasetIndex = +keys[i]; + if (datasetIndex === dsIndex) { + if (options.all) { + continue; + } + break; + } + otherValue = stack.values[datasetIndex]; + if (isNumberFinite(otherValue) && (singleMode || (value === 0 || sign(value) === sign(otherValue)))) { + value += otherValue; + } + } + return value; +} +function convertObjectDataToArray(data) { + const keys = Object.keys(data); + const adata = new Array(keys.length); + let i, ilen, key; + for (i = 0, ilen = keys.length; i < ilen; ++i) { + key = keys[i]; + adata[i] = { + x: key, + y: data[key] + }; + } + return adata; +} +function isStacked(scale, meta) { + const stacked = scale && scale.options.stacked; + return stacked || (stacked === undefined && meta.stack !== undefined); +} +function getStackKey(indexScale, valueScale, meta) { + return `${indexScale.id}.${valueScale.id}.${meta.stack || meta.type}`; +} +function getUserBounds(scale) { + const {min, max, minDefined, maxDefined} = scale.getUserBounds(); + return { + min: minDefined ? min : Number.NEGATIVE_INFINITY, + max: maxDefined ? max : Number.POSITIVE_INFINITY + }; +} +function getOrCreateStack(stacks, stackKey, indexValue) { + const subStack = stacks[stackKey] || (stacks[stackKey] = {}); + return subStack[indexValue] || (subStack[indexValue] = {}); +} +function getLastIndexInStack(stack, vScale, positive, type) { + for (const meta of vScale.getMatchingVisibleMetas(type).reverse()) { + const value = stack[meta.index]; + if ((positive && value > 0) || (!positive && value < 0)) { + return meta.index; + } + } + return null; +} +function updateStacks(controller, parsed) { + const {chart, _cachedMeta: meta} = controller; + const stacks = chart._stacks || (chart._stacks = {}); + const {iScale, vScale, index: datasetIndex} = meta; + const iAxis = iScale.axis; + const vAxis = vScale.axis; + const key = getStackKey(iScale, vScale, meta); + const ilen = parsed.length; + let stack; + for (let i = 0; i < ilen; ++i) { + const item = parsed[i]; + const {[iAxis]: index, [vAxis]: value} = item; + const itemStacks = item._stacks || (item._stacks = {}); + stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index); + stack[datasetIndex] = value; + stack._top = getLastIndexInStack(stack, vScale, true, meta.type); + stack._bottom = getLastIndexInStack(stack, vScale, false, meta.type); + } +} +function getFirstScaleId(chart, axis) { + const scales = chart.scales; + return Object.keys(scales).filter(key => scales[key].axis === axis).shift(); +} +function createDatasetContext(parent, index) { + return createContext(parent, + { + active: false, + dataset: undefined, + datasetIndex: index, + index, + mode: 'default', + type: 'dataset' + } + ); +} +function createDataContext(parent, index, element) { + return createContext(parent, { + active: false, + dataIndex: index, + parsed: undefined, + raw: undefined, + element, + index, + mode: 'default', + type: 'data' + }); +} +function clearStacks(meta, items) { + const datasetIndex = meta.controller.index; + const axis = meta.vScale && meta.vScale.axis; + if (!axis) { + return; + } + items = items || meta._parsed; + for (const parsed of items) { + const stacks = parsed._stacks; + if (!stacks || stacks[axis] === undefined || stacks[axis][datasetIndex] === undefined) { return; } - if (layout.size) { - chartArea[layout.pos] -= layout.size; - } - layout.size = layout.horizontal ? box.height : box.width; - chartArea[layout.pos] += layout.size; - if (box.getPadding) { - const boxPadding = box.getPadding(); - maxPadding.top = Math.max(maxPadding.top, boxPadding.top); - maxPadding.left = Math.max(maxPadding.left, boxPadding.left); - maxPadding.bottom = Math.max(maxPadding.bottom, boxPadding.bottom); - maxPadding.right = Math.max(maxPadding.right, boxPadding.right); - } - const newWidth = params.outerWidth - getCombinedMax(maxPadding, chartArea, 'left', 'right'); - const newHeight = params.outerHeight - getCombinedMax(maxPadding, chartArea, 'top', 'bottom'); - if (newWidth !== chartArea.w || newHeight !== chartArea.h) { - chartArea.w = newWidth; - chartArea.h = newHeight; - return layout.horizontal ? newWidth !== chartArea.w : newHeight !== chartArea.h; - } - } - function handleMaxPadding(chartArea) { - const maxPadding = chartArea.maxPadding; - function updatePos(pos) { - const change = Math.max(maxPadding[pos] - chartArea[pos], 0); - chartArea[pos] += change; - return change; - } - chartArea.y += updatePos('top'); - chartArea.x += updatePos('left'); - updatePos('right'); - updatePos('bottom'); - } - function getMargins(horizontal, chartArea) { - const maxPadding = chartArea.maxPadding; - function marginForPositions(positions) { - const margin = { - left: 0, - top: 0, - right: 0, - bottom: 0 - }; - positions.forEach(function (pos) { - margin[pos] = Math.max(chartArea[pos], maxPadding[pos]); - }); - return margin; - } - return horizontal ? marginForPositions(['left', 'right']) : marginForPositions(['top', 'bottom']); - } - function fitBoxes(boxes, chartArea, params) { - const refitBoxes = []; - let i, ilen, layout, box, refit, changed; - for (i = 0, ilen = boxes.length; i < ilen; ++i) { - layout = boxes[i]; - box = layout.box; - box.update(layout.width || chartArea.w, layout.height || chartArea.h, getMargins(layout.horizontal, chartArea)); - if (updateDims(chartArea, params, layout)) { - changed = true; - if (refitBoxes.length) { - refit = true; - } - } - if (!box.fullWidth) { - refitBoxes.push(layout); - } - } - return refit ? fitBoxes(refitBoxes, chartArea, params) || changed : changed; - } - function placeBoxes(boxes, chartArea, params) { - const userPadding = params.padding; - let x = chartArea.x; - let y = chartArea.y; - let i, ilen, layout, box; - for (i = 0, ilen = boxes.length; i < ilen; ++i) { - layout = boxes[i]; - box = layout.box; - if (layout.horizontal) { - box.left = box.fullWidth ? userPadding.left : chartArea.left; - box.right = box.fullWidth ? params.outerWidth - userPadding.right : chartArea.left + chartArea.w; - box.top = y; - box.bottom = y + box.height; - box.width = box.right - box.left; - y = box.bottom; + delete stacks[axis][datasetIndex]; + } +} +const isDirectUpdateMode = (mode) => mode === 'reset' || mode === 'none'; +const cloneIfNotShared = (cached, shared) => shared ? cached : Object.assign({}, cached); +const createStack = (canStack, meta, chart) => canStack && !meta.hidden && meta._stacked + && {keys: getSortedDatasetIndices(chart, true), values: null}; +class DatasetController { + constructor(chart, datasetIndex) { + this.chart = chart; + this._ctx = chart.ctx; + this.index = datasetIndex; + this._cachedDataOpts = {}; + this._cachedMeta = this.getMeta(); + this._type = this._cachedMeta.type; + this.options = undefined; + this._parsing = false; + this._data = undefined; + this._objectData = undefined; + this._sharedOptions = undefined; + this._drawStart = undefined; + this._drawCount = undefined; + this.enableOptionSharing = false; + this.supportsDecimation = false; + this.$context = undefined; + this._syncList = []; + this.initialize(); + } + initialize() { + const meta = this._cachedMeta; + this.configure(); + this.linkScales(); + meta._stacked = isStacked(meta.vScale, meta); + this.addElements(); + } + updateIndex(datasetIndex) { + if (this.index !== datasetIndex) { + clearStacks(this._cachedMeta); + } + this.index = datasetIndex; + } + linkScales() { + const chart = this.chart; + const meta = this._cachedMeta; + const dataset = this.getDataset(); + const chooseId = (axis, x, y, r) => axis === 'x' ? x : axis === 'r' ? r : y; + const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x')); + const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y')); + const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r')); + const indexAxis = meta.indexAxis; + const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid); + const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid); + meta.xScale = this.getScaleForId(xid); + meta.yScale = this.getScaleForId(yid); + meta.rScale = this.getScaleForId(rid); + meta.iScale = this.getScaleForId(iid); + meta.vScale = this.getScaleForId(vid); + } + getDataset() { + return this.chart.data.datasets[this.index]; + } + getMeta() { + return this.chart.getDatasetMeta(this.index); + } + getScaleForId(scaleID) { + return this.chart.scales[scaleID]; + } + _getOtherScale(scale) { + const meta = this._cachedMeta; + return scale === meta.iScale + ? meta.vScale + : meta.iScale; + } + reset() { + this._update('reset'); + } + _destroy() { + const meta = this._cachedMeta; + if (this._data) { + unlistenArrayEvents(this._data, this); + } + if (meta._stacked) { + clearStacks(meta); + } + } + _dataCheck() { + const dataset = this.getDataset(); + const data = dataset.data || (dataset.data = []); + const _data = this._data; + if (isObject(data)) { + this._data = convertObjectDataToArray(data); + } else if (_data !== data) { + if (_data) { + unlistenArrayEvents(_data, this); + const meta = this._cachedMeta; + clearStacks(meta); + meta._parsed = []; + } + if (data && Object.isExtensible(data)) { + listenArrayEvents(data, this); + } + this._syncList = []; + this._data = data; + } + } + addElements() { + const meta = this._cachedMeta; + this._dataCheck(); + if (this.datasetElementType) { + meta.dataset = new this.datasetElementType(); + } + } + buildOrUpdateElements(resetNewElements) { + const meta = this._cachedMeta; + const dataset = this.getDataset(); + let stackChanged = false; + this._dataCheck(); + const oldStacked = meta._stacked; + meta._stacked = isStacked(meta.vScale, meta); + if (meta.stack !== dataset.stack) { + stackChanged = true; + clearStacks(meta); + meta.stack = dataset.stack; + } + this._resyncElements(resetNewElements); + if (stackChanged || oldStacked !== meta._stacked) { + updateStacks(this, meta._parsed); + } + } + configure() { + const config = this.chart.config; + const scopeKeys = config.datasetScopeKeys(this._type); + const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true); + this.options = config.createResolver(scopes, this.getContext()); + this._parsing = this.options.parsing; + this._cachedDataOpts = {}; + } + parse(start, count) { + const {_cachedMeta: meta, _data: data} = this; + const {iScale, _stacked} = meta; + const iAxis = iScale.axis; + let sorted = start === 0 && count === data.length ? true : meta._sorted; + let prev = start > 0 && meta._parsed[start - 1]; + let i, cur, parsed; + if (this._parsing === false) { + meta._parsed = data; + meta._sorted = true; + parsed = data; + } else { + if (isArray(data[start])) { + parsed = this.parseArrayData(meta, data, start, count); + } else if (isObject(data[start])) { + parsed = this.parseObjectData(meta, data, start, count); } else { - box.left = x; - box.right = x + box.width; - box.top = box.fullWidth ? userPadding.top : chartArea.top; - box.bottom = box.fullWidth ? params.outerHeight - userPadding.right : chartArea.top + chartArea.h; - box.height = box.bottom - box.top; - x = box.right; + parsed = this.parsePrimitiveData(meta, data, start, count); } - } - chartArea.x = x; - chartArea.y = y; - } - defaults.set('layout', { - padding: { - top: 0, - right: 0, - bottom: 0, - left: 0 - } - }); - const layouts = { - addBox: function addBox(chart, item) { - if (!chart.boxes) { - chart.boxes = []; - } - item.fullWidth = item.fullWidth || false; - item.position = item.position || 'top'; - item.weight = item.weight || 0; - item._layers = item._layers || function () { - return [{ - z: 0, - draw: function draw(chartArea) { - item.draw(chartArea); + const isNotInOrderComparedToPrev = () => cur[iAxis] === null || (prev && cur[iAxis] < prev[iAxis]); + for (i = 0; i < count; ++i) { + meta._parsed[i + start] = cur = parsed[i]; + if (sorted) { + if (isNotInOrderComparedToPrev()) { + sorted = false; } - }]; - }; - chart.boxes.push(item); - }, - removeBox: function removeBox(chart, layoutItem) { - const index = chart.boxes ? chart.boxes.indexOf(layoutItem) : -1; - if (index !== -1) { - chart.boxes.splice(index, 1); - } - }, - configure: function configure(chart, item, options) { - const props = ['fullWidth', 'position', 'weight']; - const ilen = props.length; - let i = 0; - let prop; - for (; i < ilen; ++i) { - prop = props[i]; - if (Object.prototype.hasOwnProperty.call(options, prop)) { - item[prop] = options[prop]; + prev = cur; } } - }, - update: function update(chart, width, height) { - if (!chart) { - return; - } - const layoutOptions = chart.options.layout || {}; - const context = { - chart: chart - }; - const padding = toPadding(resolve([layoutOptions.padding], context)); - const availableWidth = width - padding.width; - const availableHeight = height - padding.height; - const boxes = buildLayoutBoxes(chart.boxes); - const verticalBoxes = boxes.vertical; - const horizontalBoxes = boxes.horizontal; - const params = Object.freeze({ - outerWidth: width, - outerHeight: height, - padding: padding, - availableWidth: availableWidth, - availableHeight: availableHeight, - vBoxMaxWidth: availableWidth / 2 / verticalBoxes.length, - hBoxMaxHeight: availableHeight / 2 - }); - const chartArea = _extends({ - maxPadding: _extends({}, padding), - w: availableWidth, - h: availableHeight, - x: padding.left, - y: padding.top - }, padding); - setLayoutDims(verticalBoxes.concat(horizontalBoxes), params); - fitBoxes(verticalBoxes, chartArea, params); - if (fitBoxes(horizontalBoxes, chartArea, params)) { - fitBoxes(verticalBoxes, chartArea, params); - } - handleMaxPadding(chartArea); - placeBoxes(boxes.leftAndTop, chartArea, params); - chartArea.x += chartArea.w; - chartArea.y += chartArea.h; - placeBoxes(boxes.rightAndBottom, chartArea, params); - chart.chartArea = { - left: chartArea.left, - top: chartArea.top, - right: chartArea.left + chartArea.w, - bottom: chartArea.top + chartArea.h, - height: chartArea.h, - width: chartArea.w + meta._sorted = sorted; + } + if (_stacked) { + updateStacks(this, parsed); + } + } + parsePrimitiveData(meta, data, start, count) { + const {iScale, vScale} = meta; + const iAxis = iScale.axis; + const vAxis = vScale.axis; + const labels = iScale.getLabels(); + const singleScale = iScale === vScale; + const parsed = new Array(count); + let i, ilen, index; + for (i = 0, ilen = count; i < ilen; ++i) { + index = i + start; + parsed[i] = { + [iAxis]: singleScale || iScale.parse(labels[index], index), + [vAxis]: vScale.parse(data[index], index) }; - each(boxes.chartArea, function (layout) { - const box = layout.box; - _extends(box, chart.chartArea); - box.update(chartArea.w, chartArea.h); - }); } - }; - - const BasePlatform = function () { - function BasePlatform() {} - const _proto = BasePlatform.prototype; - _proto.acquireContext = function acquireContext(canvas, options) {} - ; - _proto.releaseContext = function releaseContext(context) { - return false; + return parsed; + } + parseArrayData(meta, data, start, count) { + const {xScale, yScale} = meta; + const parsed = new Array(count); + let i, ilen, index, item; + for (i = 0, ilen = count; i < ilen; ++i) { + index = i + start; + item = data[index]; + parsed[i] = { + x: xScale.parse(item[0], index), + y: yScale.parse(item[1], index) + }; } - ; - _proto.addEventListener = function addEventListener(chart, type, listener) {} - ; - _proto.removeEventListener = function removeEventListener(chart, type, listener) {} - ; - _proto.getDevicePixelRatio = function getDevicePixelRatio() { - return 1; - } - ; - _proto.getMaximumSize = function getMaximumSize(element, width, height, aspectRatio) { - width = Math.max(0, width || element.width); - height = height || element.height; - return { - width: width, - height: Math.max(0, aspectRatio ? Math.floor(width / aspectRatio) : height) + return parsed; + } + parseObjectData(meta, data, start, count) { + const {xScale, yScale} = meta; + const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing; + const parsed = new Array(count); + let i, ilen, index, item; + for (i = 0, ilen = count; i < ilen; ++i) { + index = i + start; + item = data[index]; + parsed[i] = { + x: xScale.parse(resolveObjectKey(item, xAxisKey), index), + y: yScale.parse(resolveObjectKey(item, yAxisKey), index) }; } - ; - _proto.isAttached = function isAttached(canvas) { - return true; - }; - return BasePlatform; - }(); - - const BasicPlatform = function (_BasePlatform) { - _inheritsLoose(BasicPlatform, _BasePlatform); - function BasicPlatform() { - return _BasePlatform.apply(this, arguments) || this; - } - const _proto = BasicPlatform.prototype; - _proto.acquireContext = function acquireContext(item) { - return item && item.getContext && item.getContext('2d') || null; - }; - return BasicPlatform; - }(BasePlatform); - - const MapShim = function () { - if (typeof Map !== 'undefined') { - return Map; - } - function getIndex(arr, key) { - let result = -1; - arr.some(function (entry, index) { - if (entry[0] === key) { - result = index; - return true; - } - return false; - }); - return result; + return parsed; + } + getParsed(index) { + return this._cachedMeta._parsed[index]; + } + getDataElement(index) { + return this._cachedMeta.data[index]; + } + applyStack(scale, parsed, mode) { + const chart = this.chart; + const meta = this._cachedMeta; + const value = parsed[scale.axis]; + const stack = { + keys: getSortedDatasetIndices(chart, true), + values: parsed._stacks[scale.axis] + }; + return applyStack(stack, value, meta.index, {mode}); + } + updateRangeFromParsed(range, scale, parsed, stack) { + const parsedValue = parsed[scale.axis]; + let value = parsedValue === null ? NaN : parsedValue; + const values = stack && parsed._stacks[scale.axis]; + if (stack && values) { + stack.values = values; + value = applyStack(stack, parsedValue, this._cachedMeta.index); + } + range.min = Math.min(range.min, value); + range.max = Math.max(range.max, value); + } + getMinMax(scale, canStack) { + const meta = this._cachedMeta; + const _parsed = meta._parsed; + const sorted = meta._sorted && scale === meta.iScale; + const ilen = _parsed.length; + const otherScale = this._getOtherScale(scale); + const stack = createStack(canStack, meta, this.chart); + const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY}; + const {min: otherMin, max: otherMax} = getUserBounds(otherScale); + let i, parsed; + function _skip() { + parsed = _parsed[i]; + const otherValue = parsed[otherScale.axis]; + return !isNumberFinite(parsed[scale.axis]) || otherMin > otherValue || otherMax < otherValue; } - return ( - function () { - function class_1() { - this.__entries__ = []; - } - Object.defineProperty(class_1.prototype, 'size', { - get: function get() { - return this.__entries__.length; - }, - enumerable: true, - configurable: true - }); - class_1.prototype.get = function (key) { - const index = getIndex(this.__entries__, key); - const entry = this.__entries__[index]; - return entry && entry[1]; - }; - class_1.prototype.set = function (key, value) { - const index = getIndex(this.__entries__, key); - if (~index) { - this.__entries__[index][1] = value; - } else { - this.__entries__.push([key, value]); - } - }; - class_1.prototype.delete = function (key) { - const entries = this.__entries__; - const index = getIndex(entries, key); - if (~index) { - entries.splice(index, 1); - } - }; - class_1.prototype.has = function (key) { - return !!~getIndex(this.__entries__, key); - }; - class_1.prototype.clear = function () { - this.__entries__.splice(0); - }; - class_1.prototype.forEach = function (callback, ctx) { - if (ctx === void 0) { - ctx = null; - } - for (let _i = 0, _a = this.__entries__; _i < _a.length; _i++) { - const entry = _a[_i]; - callback.call(ctx, entry[1], entry[0]); - } - }; - return class_1; - }() - ); - }(); - const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document; - const global$1 = function () { - if (typeof global !== 'undefined' && global.Math === Math) { - return global; - } - if (typeof self !== 'undefined' && self.Math === Math) { - return self; - } - if (typeof window !== 'undefined' && window.Math === Math) { - return window; - } - return Function('return this')(); - }(); - const requestAnimationFrame$1 = function () { - if (typeof requestAnimationFrame === 'function') { - return requestAnimationFrame.bind(global$1); - } - return function (callback) { - return setTimeout(function () { - return callback(Date.now()); - }, 1000 / 60); - }; - }(); - const trailingTimeout = 2; - function throttle(callback, delay) { - let leadingCall = false, - trailingCall = false, - lastCallTime = 0; - function resolvePending() { - if (leadingCall) { - leadingCall = false; - callback(); - } - if (trailingCall) { - proxy(); - } - } - function timeoutCallback() { - requestAnimationFrame$1(resolvePending); - } - function proxy() { - const timeStamp = Date.now(); - if (leadingCall) { - if (timeStamp - lastCallTime < trailingTimeout) { - return; - } - trailingCall = true; - } else { - leadingCall = true; - trailingCall = false; - setTimeout(timeoutCallback, delay); - } - lastCallTime = timeStamp; - } - return proxy; - } - const REFRESH_DELAY = 20; - const transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight']; - const mutationObserverSupported = typeof MutationObserver !== 'undefined'; - const ResizeObserverController = - function () { - function ResizeObserverController() { - this.connected_ = false; - this.mutationEventsAdded_ = false; - this.mutationsObserver_ = null; - this.observers_ = []; - this.onTransitionEnd_ = this.onTransitionEnd_.bind(this); - this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY); - } - ResizeObserverController.prototype.addObserver = function (observer) { - if (!~this.observers_.indexOf(observer)) { - this.observers_.push(observer); - } - if (!this.connected_) { - this.connect_(); + for (i = 0; i < ilen; ++i) { + if (_skip()) { + continue; } - }; - ResizeObserverController.prototype.removeObserver = function (observer) { - const observers = this.observers_; - const index = observers.indexOf(observer); - if (~index) { - observers.splice(index, 1); + this.updateRangeFromParsed(range, scale, parsed, stack); + if (sorted) { + break; } - if (!observers.length && this.connected_) { - this.disconnect_(); + } + if (sorted) { + for (i = ilen - 1; i >= 0; --i) { + if (_skip()) { + continue; + } + this.updateRangeFromParsed(range, scale, parsed, stack); + break; } - }; - ResizeObserverController.prototype.refresh = function () { - const changesDetected = this.updateObservers_(); - if (changesDetected) { - this.refresh(); + } + return range; + } + getAllParsedValues(scale) { + const parsed = this._cachedMeta._parsed; + const values = []; + let i, ilen, value; + for (i = 0, ilen = parsed.length; i < ilen; ++i) { + value = parsed[i][scale.axis]; + if (isNumberFinite(value)) { + values.push(value); } - }; - ResizeObserverController.prototype.updateObservers_ = function () { - const activeObservers = this.observers_.filter(function (observer) { - return observer.gatherActive(), observer.hasActive(); - }); - activeObservers.forEach(function (observer) { - return observer.broadcastActive(); - }); - return activeObservers.length > 0; - }; - ResizeObserverController.prototype.connect_ = function () { - if (!isBrowser || this.connected_) { - return; + } + return values; + } + getMaxOverflow() { + return false; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const iScale = meta.iScale; + const vScale = meta.vScale; + const parsed = this.getParsed(index); + return { + label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '', + value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : '' + }; + } + _update(mode) { + const meta = this._cachedMeta; + this.update(mode || 'default'); + meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow()))); + } + update(mode) {} + draw() { + const ctx = this._ctx; + const chart = this.chart; + const meta = this._cachedMeta; + const elements = meta.data || []; + const area = chart.chartArea; + const active = []; + const start = this._drawStart || 0; + const count = this._drawCount || (elements.length - start); + const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop; + let i; + if (meta.dataset) { + meta.dataset.draw(ctx, area, start, count); + } + for (i = start; i < start + count; ++i) { + const element = elements[i]; + if (element.hidden) { + continue; } - document.addEventListener('transitionend', this.onTransitionEnd_); - window.addEventListener('resize', this.refresh); - if (mutationObserverSupported) { - this.mutationsObserver_ = new MutationObserver(this.refresh); - this.mutationsObserver_.observe(document, { - attributes: true, - childList: true, - characterData: true, - subtree: true - }); + if (element.active && drawActiveElementsOnTop) { + active.push(element); } else { - document.addEventListener('DOMSubtreeModified', this.refresh); - this.mutationEventsAdded_ = true; - } - this.connected_ = true; - }; - ResizeObserverController.prototype.disconnect_ = function () { - if (!isBrowser || !this.connected_) { - return; - } - document.removeEventListener('transitionend', this.onTransitionEnd_); - window.removeEventListener('resize', this.refresh); - if (this.mutationsObserver_) { - this.mutationsObserver_.disconnect(); - } - if (this.mutationEventsAdded_) { - document.removeEventListener('DOMSubtreeModified', this.refresh); - } - this.mutationsObserver_ = null; - this.mutationEventsAdded_ = false; - this.connected_ = false; - }; - ResizeObserverController.prototype.onTransitionEnd_ = function (_a) { - const _b = _a.propertyName, - propertyName = _b === void 0 ? '' : _b; - const isReflowProperty = transitionKeys.some(function (key) { - return !!~propertyName.indexOf(key); - }); - if (isReflowProperty) { - this.refresh(); - } - }; - ResizeObserverController.getInstance = function () { - if (!this.instance_) { - this.instance_ = new ResizeObserverController(); + element.draw(ctx, area); } - return this.instance_; - }; - ResizeObserverController.instance_ = null; - return ResizeObserverController; - }(); - const defineConfigurable = function defineConfigurable(target, props) { - for (let _i = 0, _a = Object.keys(props); _i < _a.length; _i++) { - const key = _a[_i]; - Object.defineProperty(target, key, { - value: props[key], - enumerable: false, - writable: false, - configurable: true - }); } - return target; - }; - const getWindowOf = function getWindowOf(target) { - const ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView; - return ownerGlobal || global$1; - }; - const emptyRect = createRectInit(0, 0, 0, 0); - function toFloat(value) { - return parseFloat(value) || 0; - } - function getBordersSize(styles) { - const positions = []; - for (let _i = 1; _i < arguments.length; _i++) { - positions[_i - 1] = arguments[_i]; - } - return positions.reduce(function (size, position) { - const value = styles['border-' + position + '-width']; - return size + toFloat(value); - }, 0); - } - function getPaddings(styles) { - const positions = ['top', 'right', 'bottom', 'left']; - const paddings = {}; - for (let _i = 0, positions_1 = positions; _i < positions_1.length; _i++) { - const position = positions_1[_i]; - const value = styles['padding-' + position]; - paddings[position] = toFloat(value); - } - return paddings; - } - function getSVGContentRect(target) { - const bbox = target.getBBox(); - return createRectInit(0, 0, bbox.width, bbox.height); - } - function getHTMLElementContentRect(target) { - const clientWidth = target.clientWidth, - clientHeight = target.clientHeight; - if (!clientWidth && !clientHeight) { - return emptyRect; - } - const styles = getWindowOf(target).getComputedStyle(target); - const paddings = getPaddings(styles); - const horizPad = paddings.left + paddings.right; - const vertPad = paddings.top + paddings.bottom; - let width = toFloat(styles.width), - height = toFloat(styles.height); - if (styles.boxSizing === 'border-box') { - if (Math.round(width + horizPad) !== clientWidth) { - width -= getBordersSize(styles, 'left', 'right') + horizPad; - } - if (Math.round(height + vertPad) !== clientHeight) { - height -= getBordersSize(styles, 'top', 'bottom') + vertPad; - } - } - if (!isDocumentElement(target)) { - const vertScrollbar = Math.round(width + horizPad) - clientWidth; - const horizScrollbar = Math.round(height + vertPad) - clientHeight; - if (Math.abs(vertScrollbar) !== 1) { - width -= vertScrollbar; - } - if (Math.abs(horizScrollbar) !== 1) { - height -= horizScrollbar; - } - } - return createRectInit(paddings.left, paddings.top, width, height); - } - const isSVGGraphicsElement = function () { - if (typeof SVGGraphicsElement !== 'undefined') { - return function (target) { - return target instanceof getWindowOf(target).SVGGraphicsElement; - }; + for (i = 0; i < active.length; ++i) { + active[i].draw(ctx, area); } - return function (target) { - return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === 'function'; - }; - }(); - function isDocumentElement(target) { - return target === getWindowOf(target).document.documentElement; - } - function getContentRect(target) { - if (!isBrowser) { - return emptyRect; - } - if (isSVGGraphicsElement(target)) { - return getSVGContentRect(target); - } - return getHTMLElementContentRect(target); - } - function createReadOnlyRect(_a) { - const x = _a.x, - y = _a.y, - width = _a.width, - height = _a.height; - const Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object; - const rect = Object.create(Constr.prototype); - defineConfigurable(rect, { - x: x, - y: y, - width: width, - height: height, - top: y, - right: x + width, - bottom: height + y, - left: x + } + getStyle(index, active) { + const mode = active ? 'active' : 'default'; + return index === undefined && this._cachedMeta.dataset + ? this.resolveDatasetElementOptions(mode) + : this.resolveDataElementOptions(index || 0, mode); + } + getContext(index, active, mode) { + const dataset = this.getDataset(); + let context; + if (index >= 0 && index < this._cachedMeta.data.length) { + const element = this._cachedMeta.data[index]; + context = element.$context || + (element.$context = createDataContext(this.getContext(), index, element)); + context.parsed = this.getParsed(index); + context.raw = dataset.data[index]; + context.index = context.dataIndex = index; + } else { + context = this.$context || + (this.$context = createDatasetContext(this.chart.getContext(), this.index)); + context.dataset = dataset; + context.index = context.datasetIndex = this.index; + } + context.active = !!active; + context.mode = mode; + return context; + } + resolveDatasetElementOptions(mode) { + return this._resolveElementOptions(this.datasetElementType.id, mode); + } + resolveDataElementOptions(index, mode) { + return this._resolveElementOptions(this.dataElementType.id, mode, index); + } + _resolveElementOptions(elementType, mode = 'default', index) { + const active = mode === 'active'; + const cache = this._cachedDataOpts; + const cacheKey = elementType + '-' + mode; + const cached = cache[cacheKey]; + const sharing = this.enableOptionSharing && defined(index); + if (cached) { + return cloneIfNotShared(cached, sharing); + } + const config = this.chart.config; + const scopeKeys = config.datasetElementScopeKeys(this._type, elementType); + const prefixes = active ? [`${elementType}Hover`, 'hover', elementType, ''] : [elementType, '']; + const scopes = config.getOptionScopes(this.getDataset(), scopeKeys); + const names = Object.keys(defaults.elements[elementType]); + const context = () => this.getContext(index, active); + const values = config.resolveNamedOptions(scopes, names, context, prefixes); + if (values.$shared) { + values.$shared = sharing; + cache[cacheKey] = Object.freeze(cloneIfNotShared(values, sharing)); + } + return values; + } + _resolveAnimations(index, transition, active) { + const chart = this.chart; + const cache = this._cachedDataOpts; + const cacheKey = `animation-${transition}`; + const cached = cache[cacheKey]; + if (cached) { + return cached; + } + let options; + if (chart.options.animation !== false) { + const config = this.chart.config; + const scopeKeys = config.datasetAnimationScopeKeys(this._type, transition); + const scopes = config.getOptionScopes(this.getDataset(), scopeKeys); + options = config.createResolver(scopes, this.getContext(index, active, transition)); + } + const animations = new Animations(chart, options && options.animations); + if (options && options._cacheable) { + cache[cacheKey] = Object.freeze(animations); + } + return animations; + } + getSharedOptions(options) { + if (!options.$shared) { + return; + } + return this._sharedOptions || (this._sharedOptions = Object.assign({}, options)); + } + includeOptions(mode, sharedOptions) { + return !sharedOptions || isDirectUpdateMode(mode) || this.chart._animationsDisabled; + } + _getSharedOptions(start, mode) { + const firstOpts = this.resolveDataElementOptions(start, mode); + const previouslySharedOptions = this._sharedOptions; + const sharedOptions = this.getSharedOptions(firstOpts); + const includeOptions = this.includeOptions(mode, sharedOptions) || (sharedOptions !== previouslySharedOptions); + this.updateSharedOptions(sharedOptions, mode, firstOpts); + return {sharedOptions, includeOptions}; + } + updateElement(element, index, properties, mode) { + if (isDirectUpdateMode(mode)) { + Object.assign(element, properties); + } else { + this._resolveAnimations(index, mode).update(element, properties); + } + } + updateSharedOptions(sharedOptions, mode, newOptions) { + if (sharedOptions && !isDirectUpdateMode(mode)) { + this._resolveAnimations(undefined, mode).update(sharedOptions, newOptions); + } + } + _setStyle(element, index, mode, active) { + element.active = active; + const options = this.getStyle(index, active); + this._resolveAnimations(index, mode, active).update(element, { + options: (!active && this.getSharedOptions(options)) || options }); - return rect; } - function createRectInit(x, y, width, height) { - return { - x: x, - y: y, - width: width, - height: height - }; + removeHoverStyle(element, datasetIndex, index) { + this._setStyle(element, index, 'active', false); } - const ResizeObservation = - function () { - function ResizeObservation(target) { - this.broadcastWidth = 0; - this.broadcastHeight = 0; - this.contentRect_ = createRectInit(0, 0, 0, 0); - this.target = target; - } - ResizeObservation.prototype.isActive = function () { - const rect = getContentRect(this.target); - this.contentRect_ = rect; - return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight; - }; - ResizeObservation.prototype.broadcastRect = function () { - const rect = this.contentRect_; - this.broadcastWidth = rect.width; - this.broadcastHeight = rect.height; - return rect; - }; - return ResizeObservation; - }(); - const ResizeObserverEntry = - function () { - function ResizeObserverEntry(target, rectInit) { - const contentRect = createReadOnlyRect(rectInit); - defineConfigurable(this, { - target: target, - contentRect: contentRect - }); + setHoverStyle(element, datasetIndex, index) { + this._setStyle(element, index, 'active', true); + } + _removeDatasetHoverStyle() { + const element = this._cachedMeta.dataset; + if (element) { + this._setStyle(element, undefined, 'active', false); } - return ResizeObserverEntry; - }(); - const ResizeObserverSPI = - function () { - function ResizeObserverSPI(callback, controller, callbackCtx) { - this.activeObservations_ = []; - this.observations_ = new MapShim(); - if (typeof callback !== 'function') { - throw new TypeError('The callback provided as parameter 1 is not a function.'); - } - this.callback_ = callback; - this.controller_ = controller; - this.callbackCtx_ = callbackCtx; - } - ResizeObserverSPI.prototype.observe = function (target) { - if (!arguments.length) { - throw new TypeError('1 argument required, but only 0 present.'); - } - if (typeof Element === 'undefined' || !(Element instanceof Object)) { - return; - } - if (!(target instanceof getWindowOf(target).Element)) { - throw new TypeError('parameter 1 is not of type "Element".'); - } - const observations = this.observations_; - if (observations.has(target)) { - return; + } + _setDatasetHoverStyle() { + const element = this._cachedMeta.dataset; + if (element) { + this._setStyle(element, undefined, 'active', true); + } + } + _resyncElements(resetNewElements) { + const data = this._data; + const elements = this._cachedMeta.data; + for (const [method, arg1, arg2] of this._syncList) { + this[method](arg1, arg2); + } + this._syncList = []; + const numMeta = elements.length; + const numData = data.length; + const count = Math.min(numData, numMeta); + if (count) { + this.parse(0, count); + } + if (numData > numMeta) { + this._insertElements(numMeta, numData - numMeta, resetNewElements); + } else if (numData < numMeta) { + this._removeElements(numData, numMeta - numData); + } + } + _insertElements(start, count, resetNewElements = true) { + const meta = this._cachedMeta; + const data = meta.data; + const end = start + count; + let i; + const move = (arr) => { + arr.length += count; + for (i = arr.length - 1; i >= end; i--) { + arr[i] = arr[i - count]; } - observations.set(target, new ResizeObservation(target)); - this.controller_.addObserver(this); - this.controller_.refresh(); }; - ResizeObserverSPI.prototype.unobserve = function (target) { - if (!arguments.length) { - throw new TypeError('1 argument required, but only 0 present.'); - } - if (typeof Element === 'undefined' || !(Element instanceof Object)) { - return; - } - if (!(target instanceof getWindowOf(target).Element)) { - throw new TypeError('parameter 1 is not of type "Element".'); - } - const observations = this.observations_; - if (!observations.has(target)) { - return; - } - observations.delete(target); - if (!observations.size) { - this.controller_.removeObserver(this); - } - }; - ResizeObserverSPI.prototype.disconnect = function () { - this.clearActive(); - this.observations_.clear(); - this.controller_.removeObserver(this); - }; - ResizeObserverSPI.prototype.gatherActive = function () { - const _this = this; - this.clearActive(); - this.observations_.forEach(function (observation) { - if (observation.isActive()) { - _this.activeObservations_.push(observation); - } - }); - }; - ResizeObserverSPI.prototype.broadcastActive = function () { - if (!this.hasActive()) { - return; - } - const ctx = this.callbackCtx_; - const entries = this.activeObservations_.map(function (observation) { - return new ResizeObserverEntry(observation.target, observation.broadcastRect()); - }); - this.callback_.call(ctx, entries, ctx); - this.clearActive(); - }; - ResizeObserverSPI.prototype.clearActive = function () { - this.activeObservations_.splice(0); - }; - ResizeObserverSPI.prototype.hasActive = function () { - return this.activeObservations_.length > 0; - }; - return ResizeObserverSPI; - }(); - const observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim(); - const ResizeObserver = - function () { - function ResizeObserver(callback) { - if (!(this instanceof ResizeObserver)) { - throw new TypeError('Cannot call a class as a function.'); - } - if (!arguments.length) { - throw new TypeError('1 argument required, but only 0 present.'); - } - const controller = ResizeObserverController.getInstance(); - const observer = new ResizeObserverSPI(callback, controller, this); - observers.set(this, observer); - } - return ResizeObserver; - }(); - ['observe', 'unobserve', 'disconnect'].forEach(function (method) { - ResizeObserver.prototype[method] = function () { - let _a; - return (_a = observers.get(this))[method].apply(_a, arguments); - }; - }); - const index = function () { - if (typeof global$1.ResizeObserver !== 'undefined') { - return global$1.ResizeObserver; - } - return ResizeObserver; - }(); - - const EXPANDO_KEY = '$chartjs'; - const EVENT_TYPES = { - touchstart: 'mousedown', - touchmove: 'mousemove', - touchend: 'mouseup', - pointerenter: 'mouseenter', - pointerdown: 'mousedown', - pointermove: 'mousemove', - pointerup: 'mouseup', - pointerleave: 'mouseout', - pointerout: 'mouseout' - }; - const isNullOrEmpty = function isNullOrEmpty(value) { - return value === null || value === ''; - }; - function initCanvas(canvas, config) { - const style = canvas.style; - const renderHeight = canvas.getAttribute('height'); - const renderWidth = canvas.getAttribute('width'); - canvas[EXPANDO_KEY] = { - initial: { - height: renderHeight, - width: renderWidth, - style: { - display: style.display, - height: style.height, - width: style.width - } - } - }; - style.display = style.display || 'block'; - style.boxSizing = style.boxSizing || 'border-box'; - if (isNullOrEmpty(renderWidth)) { - const displayWidth = readUsedSize(canvas, 'width'); - if (displayWidth !== undefined) { - canvas.width = displayWidth; + move(data); + for (i = start; i < end; ++i) { + data[i] = new this.dataElementType(); + } + if (this._parsing) { + move(meta._parsed); + } + this.parse(start, count); + if (resetNewElements) { + this.updateElements(data, start, count, 'reset'); + } + } + updateElements(element, start, count, mode) {} + _removeElements(start, count) { + const meta = this._cachedMeta; + if (this._parsing) { + const removed = meta._parsed.splice(start, count); + if (meta._stacked) { + clearStacks(meta, removed); } } - if (isNullOrEmpty(renderHeight)) { - if (canvas.style.height === '') { - canvas.height = canvas.width / (config.options.aspectRatio || 2); - } else { - const displayHeight = readUsedSize(canvas, 'height'); - if (displayHeight !== undefined) { - canvas.height = displayHeight; - } - } + meta.data.splice(start, count); + } + _sync(args) { + if (this._parsing) { + this._syncList.push(args); + } else { + const [method, arg1, arg2] = args; + this[method](arg1, arg2); } - return canvas; + this.chart._dataChanges.push([this.index, ...args]); } - const eventListenerOptions = supportsEventListenerOptions ? { - passive: true - } : false; - function addListener(node, type, listener) { - node.addEventListener(type, listener, eventListenerOptions); + _onDataPush() { + const count = arguments.length; + this._sync(['_insertElements', this.getDataset().data.length - count, count]); } - function removeListener(chart, type, listener) { - chart.canvas.removeEventListener(type, listener, eventListenerOptions); + _onDataPop() { + this._sync(['_removeElements', this._cachedMeta.data.length - 1, 1]); } - function fromNativeEvent(event, chart) { - const type = EVENT_TYPES[event.type] || event.type; - const _getRelativePosition = getRelativePosition(event, chart), - x = _getRelativePosition.x, - y = _getRelativePosition.y; - return { - type: type, - chart: chart, - native: event, - x: x !== undefined ? x : null, - y: y !== undefined ? y : null - }; + _onDataShift() { + this._sync(['_removeElements', 0, 1]); } - function createAttachObserver(chart, type, listener) { - const canvas = chart.canvas; - const container = canvas && _getParentNode(canvas); - const element = container || canvas; - const observer = new MutationObserver(function (entries) { - const parent = _getParentNode(element); - entries.forEach(function (entry) { - for (let i = 0; i < entry.addedNodes.length; i++) { - const added = entry.addedNodes[i]; - if (added === element || added === parent) { - listener(entry.target); - } - } - }); - }); - observer.observe(document, { - childList: true, - subtree: true - }); - return observer; + _onDataSplice(start, count) { + if (count) { + this._sync(['_removeElements', start, count]); + } + const newCount = arguments.length - 2; + if (newCount) { + this._sync(['_insertElements', start, newCount]); + } } - function createDetachObserver(chart, type, listener) { - const canvas = chart.canvas; - const container = canvas && _getParentNode(canvas); - if (!container) { - return; + _onDataUnshift() { + this._sync(['_insertElements', 0, arguments.length]); + } +} +DatasetController.defaults = {}; +DatasetController.prototype.datasetElementType = null; +DatasetController.prototype.dataElementType = null; + +class Element { + constructor() { + this.x = undefined; + this.y = undefined; + this.active = false; + this.options = undefined; + this.$animations = undefined; + } + tooltipPosition(useFinalPosition) { + const {x, y} = this.getProps(['x', 'y'], useFinalPosition); + return {x, y}; + } + hasValue() { + return isNumber(this.x) && isNumber(this.y); + } + getProps(props, final) { + const anims = this.$animations; + if (!final || !anims) { + return this; } - const observer = new MutationObserver(function (entries) { - entries.forEach(function (entry) { - for (let i = 0; i < entry.removedNodes.length; i++) { - if (entry.removedNodes[i] === canvas) { - listener(); - break; - } - } - }); + const ret = {}; + props.forEach(prop => { + ret[prop] = anims[prop] && anims[prop].active() ? anims[prop]._to : this[prop]; }); - observer.observe(container, { - childList: true - }); - return observer; + return ret; } - const drpListeningCharts = new Map(); - let oldDevicePixelRatio = 0; - function onWindowResize() { - const dpr = window.devicePixelRatio; - if (dpr === oldDevicePixelRatio) { - return; +} +Element.defaults = {}; +Element.defaultRoutes = undefined; + +const formatters = { + values(value) { + return isArray(value) ? value : '' + value; + }, + numeric(tickValue, index, ticks) { + if (tickValue === 0) { + return '0'; } - oldDevicePixelRatio = dpr; - drpListeningCharts.forEach(function (resize, chart) { - if (chart.currentDevicePixelRatio !== dpr) { - resize(); + const locale = this.chart.options.locale; + let notation; + let delta = tickValue; + if (ticks.length > 1) { + const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value)); + if (maxTick < 1e-4 || maxTick > 1e+15) { + notation = 'scientific'; } - }); - } - function listenDevicePixelRatioChanges(chart, resize) { - if (!drpListeningCharts.size) { - window.addEventListener('resize', onWindowResize); + delta = calculateDelta(tickValue, ticks); + } + const logDelta = log10(Math.abs(delta)); + const numDecimal = Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0); + const options = {notation, minimumFractionDigits: numDecimal, maximumFractionDigits: numDecimal}; + Object.assign(options, this.options.ticks.format); + return formatNumber(tickValue, locale, options); + }, + logarithmic(tickValue, index, ticks) { + if (tickValue === 0) { + return '0'; } - drpListeningCharts.set(chart, resize); + const remain = tickValue / (Math.pow(10, Math.floor(log10(tickValue)))); + if (remain === 1 || remain === 2 || remain === 5) { + return formatters.numeric.call(this, tickValue, index, ticks); + } + return ''; + } +}; +function calculateDelta(tickValue, ticks) { + let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value; + if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) { + delta = tickValue - Math.floor(tickValue); + } + return delta; +} +var Ticks = {formatters}; + +defaults.set('scale', { + display: true, + offset: false, + reverse: false, + beginAtZero: false, + bounds: 'ticks', + grace: 0, + grid: { + display: true, + lineWidth: 1, + drawBorder: true, + drawOnChartArea: true, + drawTicks: true, + tickLength: 8, + tickWidth: (_ctx, options) => options.lineWidth, + tickColor: (_ctx, options) => options.color, + offset: false, + borderDash: [], + borderDashOffset: 0.0, + borderWidth: 1 + }, + title: { + display: false, + text: '', + padding: { + top: 4, + bottom: 4 + } + }, + ticks: { + minRotation: 0, + maxRotation: 50, + mirror: false, + textStrokeWidth: 0, + textStrokeColor: '', + padding: 3, + display: true, + autoSkip: true, + autoSkipPadding: 3, + labelOffset: 0, + callback: Ticks.formatters.values, + minor: {}, + major: {}, + align: 'center', + crossAlign: 'near', + showLabelBackdrop: false, + backdropColor: 'rgba(255, 255, 255, 0.75)', + backdropPadding: 2, + } +}); +defaults.route('scale.ticks', 'color', '', 'color'); +defaults.route('scale.grid', 'color', '', 'borderColor'); +defaults.route('scale.grid', 'borderColor', '', 'borderColor'); +defaults.route('scale.title', 'color', '', 'color'); +defaults.describe('scale', { + _fallback: false, + _scriptable: (name) => !name.startsWith('before') && !name.startsWith('after') && name !== 'callback' && name !== 'parser', + _indexable: (name) => name !== 'borderDash' && name !== 'tickBorderDash', +}); +defaults.describe('scales', { + _fallback: 'scale', +}); +defaults.describe('scale.ticks', { + _scriptable: (name) => name !== 'backdropPadding' && name !== 'callback', + _indexable: (name) => name !== 'backdropPadding', +}); + +function autoSkip(scale, ticks) { + const tickOpts = scale.options.ticks; + const ticksLimit = tickOpts.maxTicksLimit || determineMaxTicks(scale); + const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : []; + const numMajorIndices = majorIndices.length; + const first = majorIndices[0]; + const last = majorIndices[numMajorIndices - 1]; + const newTicks = []; + if (numMajorIndices > ticksLimit) { + skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit); + return newTicks; + } + const spacing = calculateSpacing(majorIndices, ticks, ticksLimit); + if (numMajorIndices > 0) { + let i, ilen; + const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null; + skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first); + for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) { + skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]); + } + skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing); + return newTicks; + } + skip(ticks, newTicks, spacing); + return newTicks; +} +function determineMaxTicks(scale) { + const offset = scale.options.offset; + const tickLength = scale._tickSize(); + const maxScale = scale._length / tickLength + (offset ? 0 : 1); + const maxChart = scale._maxLength / tickLength; + return Math.floor(Math.min(maxScale, maxChart)); +} +function calculateSpacing(majorIndices, ticks, ticksLimit) { + const evenMajorSpacing = getEvenSpacing(majorIndices); + const spacing = ticks.length / ticksLimit; + if (!evenMajorSpacing) { + return Math.max(spacing, 1); } - function unlistenDevicePixelRatioChanges(chart) { - drpListeningCharts.delete(chart); - if (!drpListeningCharts.size) { - window.removeEventListener('resize', onWindowResize); + const factors = _factorize(evenMajorSpacing); + for (let i = 0, ilen = factors.length - 1; i < ilen; i++) { + const factor = factors[i]; + if (factor > spacing) { + return factor; + } + } + return Math.max(spacing, 1); +} +function getMajorIndices(ticks) { + const result = []; + let i, ilen; + for (i = 0, ilen = ticks.length; i < ilen; i++) { + if (ticks[i].major) { + result.push(i); + } + } + return result; +} +function skipMajors(ticks, newTicks, majorIndices, spacing) { + let count = 0; + let next = majorIndices[0]; + let i; + spacing = Math.ceil(spacing); + for (i = 0; i < ticks.length; i++) { + if (i === next) { + newTicks.push(ticks[i]); + count++; + next = majorIndices[count * spacing]; + } + } +} +function skip(ticks, newTicks, spacing, majorStart, majorEnd) { + const start = valueOrDefault(majorStart, 0); + const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length); + let count = 0; + let length, i, next; + spacing = Math.ceil(spacing); + if (majorEnd) { + length = majorEnd - majorStart; + spacing = length / Math.floor(length / spacing); + } + next = start; + while (next < 0) { + count++; + next = Math.round(start + count * spacing); + } + for (i = Math.max(start, 0); i < end; i++) { + if (i === next) { + newTicks.push(ticks[i]); + count++; + next = Math.round(start + count * spacing); } } - function createResizeObserver(chart, type, listener) { - const canvas = chart.canvas; - const container = canvas && _getParentNode(canvas); - if (!container) { - return; +} +function getEvenSpacing(arr) { + const len = arr.length; + let i, diff; + if (len < 2) { + return false; + } + for (diff = arr[0], i = 1; i < len; ++i) { + if (arr[i] - arr[i - 1] !== diff) { + return false; } - const resize = throttled(function (width, height) { - const w = container.clientWidth; - listener(width, height); - if (w < container.clientWidth) { - listener(); - } - }, window); - const observer = new index(function (entries) { - const entry = entries[0]; - const width = entry.contentRect.width; - const height = entry.contentRect.height; - if (width === 0 && height === 0) { - return; - } - resize(width, height); - }); - observer.observe(container); - listenDevicePixelRatioChanges(chart, resize); - return observer; } - function releaseObserver(chart, type, observer) { - if (observer) { - observer.disconnect(); + return diff; +} + +const reverseAlign = (align) => align === 'left' ? 'right' : align === 'right' ? 'left' : align; +const offsetFromEdge = (scale, edge, offset) => edge === 'top' || edge === 'left' ? scale[edge] + offset : scale[edge] - offset; +function sample(arr, numItems) { + const result = []; + const increment = arr.length / numItems; + const len = arr.length; + let i = 0; + for (; i < len; i += increment) { + result.push(arr[Math.floor(i)]); + } + return result; +} +function getPixelForGridLine(scale, index, offsetGridLines) { + const length = scale.ticks.length; + const validIndex = Math.min(index, length - 1); + const start = scale._startPixel; + const end = scale._endPixel; + const epsilon = 1e-6; + let lineValue = scale.getPixelForTick(validIndex); + let offset; + if (offsetGridLines) { + if (length === 1) { + offset = Math.max(lineValue - start, end - lineValue); + } else if (index === 0) { + offset = (scale.getPixelForTick(1) - lineValue) / 2; + } else { + offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2; } - if (type === 'resize') { - unlistenDevicePixelRatioChanges(chart); + lineValue += validIndex < index ? offset : -offset; + if (lineValue < start - epsilon || lineValue > end + epsilon) { + return; } } - function createProxyAndListen(chart, type, listener) { - const canvas = chart.canvas; - const proxy = throttled(function (event) { - if (chart.ctx !== null) { - listener(fromNativeEvent(event, chart)); + return lineValue; +} +function garbageCollect(caches, length) { + each(caches, (cache) => { + const gc = cache.gc; + const gcLen = gc.length / 2; + let i; + if (gcLen > length) { + for (i = 0; i < gcLen; ++i) { + delete cache.data[gc[i]]; } - }, chart, function (args) { - const event = args[0]; - return [event, event.offsetX, event.offsetY]; - }); - addListener(canvas, type, proxy); - return proxy; + gc.splice(0, gcLen); + } + }); +} +function getTickMarkLength(options) { + return options.drawTicks ? options.tickLength : 0; +} +function getTitleHeight(options, fallback) { + if (!options.display) { + return 0; + } + const font = toFont(options.font, fallback); + const padding = toPadding(options.padding); + const lines = isArray(options.text) ? options.text.length : 1; + return (lines * font.lineHeight) + padding.height; +} +function createScaleContext(parent, scale) { + return createContext(parent, { + scale, + type: 'scale' + }); +} +function createTickContext(parent, index, tick) { + return createContext(parent, { + tick, + index, + type: 'tick' + }); +} +function titleAlign(align, position, reverse) { + let ret = _toLeftRightCenter(align); + if ((reverse && position !== 'right') || (!reverse && position === 'right')) { + ret = reverseAlign(ret); + } + return ret; +} +function titleArgs(scale, offset, position, align) { + const {top, left, bottom, right, chart} = scale; + const {chartArea, scales} = chart; + let rotation = 0; + let maxWidth, titleX, titleY; + const height = bottom - top; + const width = right - left; + if (scale.isHorizontal()) { + titleX = _alignStartEnd(align, left, right); + if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + titleY = scales[positionAxisID].getPixelForValue(value) + height - offset; + } else if (position === 'center') { + titleY = (chartArea.bottom + chartArea.top) / 2 + height - offset; + } else { + titleY = offsetFromEdge(scale, position, offset); + } + maxWidth = right - left; + } else { + if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + titleX = scales[positionAxisID].getPixelForValue(value) - width + offset; + } else if (position === 'center') { + titleX = (chartArea.left + chartArea.right) / 2 - width + offset; + } else { + titleX = offsetFromEdge(scale, position, offset); + } + titleY = _alignStartEnd(align, bottom, top); + rotation = position === 'left' ? -HALF_PI : HALF_PI; + } + return {titleX, titleY, maxWidth, rotation}; +} +class Scale extends Element { + constructor(cfg) { + super(); + this.id = cfg.id; + this.type = cfg.type; + this.options = undefined; + this.ctx = cfg.ctx; + this.chart = cfg.chart; + this.top = undefined; + this.bottom = undefined; + this.left = undefined; + this.right = undefined; + this.width = undefined; + this.height = undefined; + this._margins = { + left: 0, + right: 0, + top: 0, + bottom: 0 + }; + this.maxWidth = undefined; + this.maxHeight = undefined; + this.paddingTop = undefined; + this.paddingBottom = undefined; + this.paddingLeft = undefined; + this.paddingRight = undefined; + this.axis = undefined; + this.labelRotation = undefined; + this.min = undefined; + this.max = undefined; + this._range = undefined; + this.ticks = []; + this._gridLineItems = null; + this._labelItems = null; + this._labelSizes = null; + this._length = 0; + this._maxLength = 0; + this._longestTextCache = {}; + this._startPixel = undefined; + this._endPixel = undefined; + this._reversePixels = false; + this._userMax = undefined; + this._userMin = undefined; + this._suggestedMax = undefined; + this._suggestedMin = undefined; + this._ticksLength = 0; + this._borderValue = 0; + this._cache = {}; + this._dataLimitsCached = false; + this.$context = undefined; + } + init(options) { + this.options = options.setContext(this.getContext()); + this.axis = options.axis; + this._userMin = this.parse(options.min); + this._userMax = this.parse(options.max); + this._suggestedMin = this.parse(options.suggestedMin); + this._suggestedMax = this.parse(options.suggestedMax); + } + parse(raw, index) { + return raw; + } + getUserBounds() { + let {_userMin, _userMax, _suggestedMin, _suggestedMax} = this; + _userMin = finiteOrDefault(_userMin, Number.POSITIVE_INFINITY); + _userMax = finiteOrDefault(_userMax, Number.NEGATIVE_INFINITY); + _suggestedMin = finiteOrDefault(_suggestedMin, Number.POSITIVE_INFINITY); + _suggestedMax = finiteOrDefault(_suggestedMax, Number.NEGATIVE_INFINITY); + return { + min: finiteOrDefault(_userMin, _suggestedMin), + max: finiteOrDefault(_userMax, _suggestedMax), + minDefined: isNumberFinite(_userMin), + maxDefined: isNumberFinite(_userMax) + }; } - const DomPlatform = function (_BasePlatform) { - _inheritsLoose(DomPlatform, _BasePlatform); - function DomPlatform() { - return _BasePlatform.apply(this, arguments) || this; + getMinMax(canStack) { + let {min, max, minDefined, maxDefined} = this.getUserBounds(); + let range; + if (minDefined && maxDefined) { + return {min, max}; } - const _proto = DomPlatform.prototype; - _proto.acquireContext = function acquireContext(canvas, config) { - const context = canvas && canvas.getContext && canvas.getContext('2d'); - if (context && context.canvas === canvas) { - initCanvas(canvas, config); - return context; + const metas = this.getMatchingVisibleMetas(); + for (let i = 0, ilen = metas.length; i < ilen; ++i) { + range = metas[i].controller.getMinMax(this, canStack); + if (!minDefined) { + min = Math.min(min, range.min); } - return null; - } - ; - _proto.releaseContext = function releaseContext(context) { - const canvas = context.canvas; - if (!canvas[EXPANDO_KEY]) { - return false; + if (!maxDefined) { + max = Math.max(max, range.max); } - const initial = canvas[EXPANDO_KEY].initial; - ['height', 'width'].forEach(function (prop) { - const value = initial[prop]; - if (isNullOrUndef(value)) { - canvas.removeAttribute(prop); - } else { - canvas.setAttribute(prop, value); - } - }); - const style = initial.style || {}; - Object.keys(style).forEach(function (key) { - canvas.style[key] = style[key]; - }); - canvas.width = canvas.width; - delete canvas[EXPANDO_KEY]; - return true; } - ; - _proto.addEventListener = function addEventListener(chart, type, listener) { - this.removeEventListener(chart, type); - const proxies = chart.$proxies || (chart.$proxies = {}); - const handlers = { - attach: createAttachObserver, - detach: createDetachObserver, - resize: createResizeObserver - }; - const handler = handlers[type] || createProxyAndListen; - proxies[type] = handler(chart, type, listener); - } - ; - _proto.removeEventListener = function removeEventListener(chart, type) { - const proxies = chart.$proxies || (chart.$proxies = {}); - const proxy = proxies[type]; - if (!proxy) { - return; - } - const handlers = { - attach: releaseObserver, - detach: releaseObserver, - resize: releaseObserver - }; - const handler = handlers[type] || removeListener; - handler(chart, type, proxy); - proxies[type] = undefined; + min = maxDefined && min > max ? max : min; + max = minDefined && min > max ? min : max; + return { + min: finiteOrDefault(min, finiteOrDefault(max, min)), + max: finiteOrDefault(max, finiteOrDefault(min, max)) }; - _proto.getDevicePixelRatio = function getDevicePixelRatio() { - return window.devicePixelRatio; - } - ; - _proto.getMaximumSize = function getMaximumSize$1(canvas, width, height, aspectRatio) { - return getMaximumSize(canvas, width, height, aspectRatio); + } + getPadding() { + return { + left: this.paddingLeft || 0, + top: this.paddingTop || 0, + right: this.paddingRight || 0, + bottom: this.paddingBottom || 0 + }; + } + getTicks() { + return this.ticks; + } + getLabels() { + const data = this.chart.data; + return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || []; + } + beforeLayout() { + this._cache = {}; + this._dataLimitsCached = false; + } + beforeUpdate() { + callback(this.options.beforeUpdate, [this]); + } + update(maxWidth, maxHeight, margins) { + const {beginAtZero, grace, ticks: tickOpts} = this.options; + const sampleSize = tickOpts.sampleSize; + this.beforeUpdate(); + this.maxWidth = maxWidth; + this.maxHeight = maxHeight; + this._margins = margins = Object.assign({ + left: 0, + right: 0, + top: 0, + bottom: 0 + }, margins); + this.ticks = null; + this._labelSizes = null; + this._gridLineItems = null; + this._labelItems = null; + this.beforeSetDimensions(); + this.setDimensions(); + this.afterSetDimensions(); + this._maxLength = this.isHorizontal() + ? this.width + margins.left + margins.right + : this.height + margins.top + margins.bottom; + if (!this._dataLimitsCached) { + this.beforeDataLimits(); + this.determineDataLimits(); + this.afterDataLimits(); + this._range = _addGrace(this, grace, beginAtZero); + this._dataLimitsCached = true; + } + this.beforeBuildTicks(); + this.ticks = this.buildTicks() || []; + this.afterBuildTicks(); + const samplingEnabled = sampleSize < this.ticks.length; + this._convertTicksToLabels(samplingEnabled ? sample(this.ticks, sampleSize) : this.ticks); + this.configure(); + this.beforeCalculateLabelRotation(); + this.calculateLabelRotation(); + this.afterCalculateLabelRotation(); + if (tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto')) { + this.ticks = autoSkip(this, this.ticks); + this._labelSizes = null; + this.afterAutoSkip(); + } + if (samplingEnabled) { + this._convertTicksToLabels(this.ticks); + } + this.beforeFit(); + this.fit(); + this.afterFit(); + this.afterUpdate(); + } + configure() { + let reversePixels = this.options.reverse; + let startPixel, endPixel; + if (this.isHorizontal()) { + startPixel = this.left; + endPixel = this.right; + } else { + startPixel = this.top; + endPixel = this.bottom; + reversePixels = !reversePixels; + } + this._startPixel = startPixel; + this._endPixel = endPixel; + this._reversePixels = reversePixels; + this._length = endPixel - startPixel; + this._alignToPixels = this.options.alignToPixels; + } + afterUpdate() { + callback(this.options.afterUpdate, [this]); + } + beforeSetDimensions() { + callback(this.options.beforeSetDimensions, [this]); + } + setDimensions() { + if (this.isHorizontal()) { + this.width = this.maxWidth; + this.left = 0; + this.right = this.width; + } else { + this.height = this.maxHeight; + this.top = 0; + this.bottom = this.height; } - ; - _proto.isAttached = function isAttached(canvas) { - const container = _getParentNode(canvas); - return !!(container && _getParentNode(container)); - }; - return DomPlatform; - }(BasePlatform); - - const platforms = /*#__PURE__*/Object.freeze({ - __proto__: null, - BasePlatform: BasePlatform, - BasicPlatform: BasicPlatform, - DomPlatform: DomPlatform - }); - - function finallyConstructor(callback) { - const constructor = this.constructor; - return this.then(function (value) { - return constructor.resolve(callback()).then(function () { - return value; - }); - }, function (reason) { - return constructor.resolve(callback()).then(function () { - return constructor.reject(reason); - }); - }); + this.paddingLeft = 0; + this.paddingTop = 0; + this.paddingRight = 0; + this.paddingBottom = 0; } - - function allSettled(arr) { - const P = this; - return new P(function (resolve, reject) { - if (!(arr && typeof arr.length !== 'undefined')) { - return reject(new TypeError(typeof arr + ' ' + arr + ' is not iterable(cannot read property Symbol(Symbol.iterator))')); - } - const args = Array.prototype.slice.call(arr); - if (args.length === 0) return resolve([]); - let remaining = args.length; - function res(i, val) { - if (val && (typeof val === 'object' || typeof val === 'function')) { - const then = val.then; - if (typeof then === 'function') { - then.call(val, function (val) { - res(i, val); - }, function (e) { - args[i] = { - status: 'rejected', - reason: e - }; - if (--remaining === 0) { - resolve(args); - } - }); - return; - } - } - args[i] = { - status: 'fulfilled', - value: val - }; - if (--remaining === 0) { - resolve(args); + afterSetDimensions() { + callback(this.options.afterSetDimensions, [this]); + } + _callHooks(name) { + this.chart.notifyPlugins(name, this.getContext()); + callback(this.options[name], [this]); + } + beforeDataLimits() { + this._callHooks('beforeDataLimits'); + } + determineDataLimits() {} + afterDataLimits() { + this._callHooks('afterDataLimits'); + } + beforeBuildTicks() { + this._callHooks('beforeBuildTicks'); + } + buildTicks() { + return []; + } + afterBuildTicks() { + this._callHooks('afterBuildTicks'); + } + beforeTickToLabelConversion() { + callback(this.options.beforeTickToLabelConversion, [this]); + } + generateTickLabels(ticks) { + const tickOpts = this.options.ticks; + let i, ilen, tick; + for (i = 0, ilen = ticks.length; i < ilen; i++) { + tick = ticks[i]; + tick.label = callback(tickOpts.callback, [tick.value, i, ticks], this); + } + } + afterTickToLabelConversion() { + callback(this.options.afterTickToLabelConversion, [this]); + } + beforeCalculateLabelRotation() { + callback(this.options.beforeCalculateLabelRotation, [this]); + } + calculateLabelRotation() { + const options = this.options; + const tickOpts = options.ticks; + const numTicks = this.ticks.length; + const minRotation = tickOpts.minRotation || 0; + const maxRotation = tickOpts.maxRotation; + let labelRotation = minRotation; + let tickWidth, maxHeight, maxLabelDiagonal; + if (!this._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !this.isHorizontal()) { + this.labelRotation = minRotation; + return; + } + const labelSizes = this._getLabelSizes(); + const maxLabelWidth = labelSizes.widest.width; + const maxLabelHeight = labelSizes.highest.height; + const maxWidth = _limitValue(this.chart.width - maxLabelWidth, 0, this.maxWidth); + tickWidth = options.offset ? this.maxWidth / numTicks : maxWidth / (numTicks - 1); + if (maxLabelWidth + 6 > tickWidth) { + tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1)); + maxHeight = this.maxHeight - getTickMarkLength(options.grid) + - tickOpts.padding - getTitleHeight(options.title, this.chart.options.font); + maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight); + labelRotation = toDegrees(Math.min( + Math.asin(_limitValue((labelSizes.highest.height + 6) / tickWidth, -1, 1)), + Math.asin(_limitValue(maxHeight / maxLabelDiagonal, -1, 1)) - Math.asin(_limitValue(maxLabelHeight / maxLabelDiagonal, -1, 1)) + )); + labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation)); + } + this.labelRotation = labelRotation; + } + afterCalculateLabelRotation() { + callback(this.options.afterCalculateLabelRotation, [this]); + } + afterAutoSkip() {} + beforeFit() { + callback(this.options.beforeFit, [this]); + } + fit() { + const minSize = { + width: 0, + height: 0 + }; + const {chart, options: {ticks: tickOpts, title: titleOpts, grid: gridOpts}} = this; + const display = this._isVisible(); + const isHorizontal = this.isHorizontal(); + if (display) { + const titleHeight = getTitleHeight(titleOpts, chart.options.font); + if (isHorizontal) { + minSize.width = this.maxWidth; + minSize.height = getTickMarkLength(gridOpts) + titleHeight; + } else { + minSize.height = this.maxHeight; + minSize.width = getTickMarkLength(gridOpts) + titleHeight; + } + if (tickOpts.display && this.ticks.length) { + const {first, last, widest, highest} = this._getLabelSizes(); + const tickPadding = tickOpts.padding * 2; + const angleRadians = toRadians(this.labelRotation); + const cos = Math.cos(angleRadians); + const sin = Math.sin(angleRadians); + if (isHorizontal) { + const labelHeight = tickOpts.mirror ? 0 : sin * widest.width + cos * highest.height; + minSize.height = Math.min(this.maxHeight, minSize.height + labelHeight + tickPadding); + } else { + const labelWidth = tickOpts.mirror ? 0 : cos * widest.width + sin * highest.height; + minSize.width = Math.min(this.maxWidth, minSize.width + labelWidth + tickPadding); } + this._calculatePadding(first, last, sin, cos); } - for (let i = 0; i < args.length; i++) { - res(i, args[i]); + } + this._handleMargins(); + if (isHorizontal) { + this.width = this._length = chart.width - this._margins.left - this._margins.right; + this.height = minSize.height; + } else { + this.width = minSize.width; + this.height = this._length = chart.height - this._margins.top - this._margins.bottom; + } + } + _calculatePadding(first, last, sin, cos) { + const {ticks: {align, padding}, position} = this.options; + const isRotated = this.labelRotation !== 0; + const labelsBelowTicks = position !== 'top' && this.axis === 'x'; + if (this.isHorizontal()) { + const offsetLeft = this.getPixelForTick(0) - this.left; + const offsetRight = this.right - this.getPixelForTick(this.ticks.length - 1); + let paddingLeft = 0; + let paddingRight = 0; + if (isRotated) { + if (labelsBelowTicks) { + paddingLeft = cos * first.width; + paddingRight = sin * last.height; + } else { + paddingLeft = sin * first.height; + paddingRight = cos * last.width; + } + } else if (align === 'start') { + paddingRight = last.width; + } else if (align === 'end') { + paddingLeft = first.width; + } else if (align !== 'inner') { + paddingLeft = first.width / 2; + paddingRight = last.width / 2; + } + this.paddingLeft = Math.max((paddingLeft - offsetLeft + padding) * this.width / (this.width - offsetLeft), 0); + this.paddingRight = Math.max((paddingRight - offsetRight + padding) * this.width / (this.width - offsetRight), 0); + } else { + let paddingTop = last.height / 2; + let paddingBottom = first.height / 2; + if (align === 'start') { + paddingTop = 0; + paddingBottom = first.height; + } else if (align === 'end') { + paddingTop = last.height; + paddingBottom = 0; } - }); - } - - const setTimeoutFunc = setTimeout; - function isArray$1(x) { - return Boolean(x && typeof x.length !== 'undefined'); - } - function noop$1() {} - function bind(fn, thisArg) { - return function () { - fn.apply(thisArg, arguments); - }; + this.paddingTop = paddingTop + padding; + this.paddingBottom = paddingBottom + padding; + } } - function Promise(fn) { - if (!(this instanceof Promise)) throw new TypeError('Promises must be constructed via new'); - if (typeof fn !== 'function') throw new TypeError('not a function'); - this._state = 0; - this._handled = false; - this._value = undefined; - this._deferreds = []; - doResolve(fn, this); - } - function handle(self, deferred) { - while (self._state === 3) { - self = self._value; - } - if (self._state === 0) { - self._deferreds.push(deferred); - return; + _handleMargins() { + if (this._margins) { + this._margins.left = Math.max(this.paddingLeft, this._margins.left); + this._margins.top = Math.max(this.paddingTop, this._margins.top); + this._margins.right = Math.max(this.paddingRight, this._margins.right); + this._margins.bottom = Math.max(this.paddingBottom, this._margins.bottom); } - self._handled = true; - Promise._immediateFn(function () { - const cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected; - if (cb === null) { - (self._state === 1 ? resolve$1 : reject)(deferred.promise, self._value); - return; + } + afterFit() { + callback(this.options.afterFit, [this]); + } + isHorizontal() { + const {axis, position} = this.options; + return position === 'top' || position === 'bottom' || axis === 'x'; + } + isFullSize() { + return this.options.fullSize; + } + _convertTicksToLabels(ticks) { + this.beforeTickToLabelConversion(); + this.generateTickLabels(ticks); + let i, ilen; + for (i = 0, ilen = ticks.length; i < ilen; i++) { + if (isNullOrUndef(ticks[i].label)) { + ticks.splice(i, 1); + ilen--; + i--; } - let ret; - try { - ret = cb(self._value); - } catch (e) { - reject(deferred.promise, e); - return; + } + this.afterTickToLabelConversion(); + } + _getLabelSizes() { + let labelSizes = this._labelSizes; + if (!labelSizes) { + const sampleSize = this.options.ticks.sampleSize; + let ticks = this.ticks; + if (sampleSize < ticks.length) { + ticks = sample(ticks, sampleSize); } - resolve$1(deferred.promise, ret); - }); + this._labelSizes = labelSizes = this._computeLabelSizes(ticks, ticks.length); + } + return labelSizes; } - function resolve$1(self, newValue) { - try { - if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.'); - if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) { - const then = newValue.then; - if (newValue instanceof Promise) { - self._state = 3; - self._value = newValue; - finale(self); - return; - } else if (typeof then === 'function') { - doResolve(bind(then, newValue), self); - return; + _computeLabelSizes(ticks, length) { + const {ctx, _longestTextCache: caches} = this; + const widths = []; + const heights = []; + let widestLabelSize = 0; + let highestLabelSize = 0; + let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel; + for (i = 0; i < length; ++i) { + label = ticks[i].label; + tickFont = this._resolveTickFontOptions(i); + ctx.font = fontString = tickFont.string; + cache = caches[fontString] = caches[fontString] || {data: {}, gc: []}; + lineHeight = tickFont.lineHeight; + width = height = 0; + if (!isNullOrUndef(label) && !isArray(label)) { + width = _measureText(ctx, cache.data, cache.gc, width, label); + height = lineHeight; + } else if (isArray(label)) { + for (j = 0, jlen = label.length; j < jlen; ++j) { + nestedLabel = label[j]; + if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) { + width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel); + height += lineHeight; + } } } - self._state = 1; - self._value = newValue; - finale(self); - } catch (e) { - reject(self, e); + widths.push(width); + heights.push(height); + widestLabelSize = Math.max(width, widestLabelSize); + highestLabelSize = Math.max(height, highestLabelSize); } + garbageCollect(caches, length); + const widest = widths.indexOf(widestLabelSize); + const highest = heights.indexOf(highestLabelSize); + const valueAt = (idx) => ({width: widths[idx] || 0, height: heights[idx] || 0}); + return { + first: valueAt(0), + last: valueAt(length - 1), + widest: valueAt(widest), + highest: valueAt(highest), + widths, + heights, + }; } - function reject(self, newValue) { - self._state = 2; - self._value = newValue; - finale(self); + getLabelForValue(value) { + return value; } - function finale(self) { - if (self._state === 2 && self._deferreds.length === 0) { - Promise._immediateFn(function () { - if (!self._handled) { - Promise._unhandledRejectionFn(self._value); - } - }); + getPixelForValue(value, index) { + return NaN; + } + getValueForPixel(pixel) {} + getPixelForTick(index) { + const ticks = this.ticks; + if (index < 0 || index > ticks.length - 1) { + return null; + } + return this.getPixelForValue(ticks[index].value); + } + getPixelForDecimal(decimal) { + if (this._reversePixels) { + decimal = 1 - decimal; } - for (let i = 0, len = self._deferreds.length; i < len; i++) { - handle(self, self._deferreds[i]); - } - self._deferreds = null; - } - function Handler(onFulfilled, onRejected, promise) { - this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null; - this.onRejected = typeof onRejected === 'function' ? onRejected : null; - this.promise = promise; - } - function doResolve(fn, self) { - let done = false; - try { - fn(function (value) { - if (done) return; - done = true; - resolve$1(self, value); - }, function (reason) { - if (done) return; - done = true; - reject(self, reason); + const pixel = this._startPixel + decimal * this._length; + return _int16Range(this._alignToPixels ? _alignPixel(this.chart, pixel, 0) : pixel); + } + getDecimalForPixel(pixel) { + const decimal = (pixel - this._startPixel) / this._length; + return this._reversePixels ? 1 - decimal : decimal; + } + getBasePixel() { + return this.getPixelForValue(this.getBaseValue()); + } + getBaseValue() { + const {min, max} = this; + return min < 0 && max < 0 ? max : + min > 0 && max > 0 ? min : + 0; + } + getContext(index) { + const ticks = this.ticks || []; + if (index >= 0 && index < ticks.length) { + const tick = ticks[index]; + return tick.$context || + (tick.$context = createTickContext(this.getContext(), index, tick)); + } + return this.$context || + (this.$context = createScaleContext(this.chart.getContext(), this)); + } + _tickSize() { + const optionTicks = this.options.ticks; + const rot = toRadians(this.labelRotation); + const cos = Math.abs(Math.cos(rot)); + const sin = Math.abs(Math.sin(rot)); + const labelSizes = this._getLabelSizes(); + const padding = optionTicks.autoSkipPadding || 0; + const w = labelSizes ? labelSizes.widest.width + padding : 0; + const h = labelSizes ? labelSizes.highest.height + padding : 0; + return this.isHorizontal() + ? h * cos > w * sin ? w / cos : h / sin + : h * sin < w * cos ? h / cos : w / sin; + } + _isVisible() { + const display = this.options.display; + if (display !== 'auto') { + return !!display; + } + return this.getMatchingVisibleMetas().length > 0; + } + _computeGridLineItems(chartArea) { + const axis = this.axis; + const chart = this.chart; + const options = this.options; + const {grid, position} = options; + const offset = grid.offset; + const isHorizontal = this.isHorizontal(); + const ticks = this.ticks; + const ticksLength = ticks.length + (offset ? 1 : 0); + const tl = getTickMarkLength(grid); + const items = []; + const borderOpts = grid.setContext(this.getContext()); + const axisWidth = borderOpts.drawBorder ? borderOpts.borderWidth : 0; + const axisHalfWidth = axisWidth / 2; + const alignBorderValue = function(pixel) { + return _alignPixel(chart, pixel, axisWidth); + }; + let borderValue, i, lineValue, alignedLineValue; + let tx1, ty1, tx2, ty2, x1, y1, x2, y2; + if (position === 'top') { + borderValue = alignBorderValue(this.bottom); + ty1 = this.bottom - tl; + ty2 = borderValue - axisHalfWidth; + y1 = alignBorderValue(chartArea.top) + axisHalfWidth; + y2 = chartArea.bottom; + } else if (position === 'bottom') { + borderValue = alignBorderValue(this.top); + y1 = chartArea.top; + y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth; + ty1 = borderValue + axisHalfWidth; + ty2 = this.top + tl; + } else if (position === 'left') { + borderValue = alignBorderValue(this.right); + tx1 = this.right - tl; + tx2 = borderValue - axisHalfWidth; + x1 = alignBorderValue(chartArea.left) + axisHalfWidth; + x2 = chartArea.right; + } else if (position === 'right') { + borderValue = alignBorderValue(this.left); + x1 = chartArea.left; + x2 = alignBorderValue(chartArea.right) - axisHalfWidth; + tx1 = borderValue + axisHalfWidth; + tx2 = this.left + tl; + } else if (axis === 'x') { + if (position === 'center') { + borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2 + 0.5); + } else if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value)); + } + y1 = chartArea.top; + y2 = chartArea.bottom; + ty1 = borderValue + axisHalfWidth; + ty2 = ty1 + tl; + } else if (axis === 'y') { + if (position === 'center') { + borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2); + } else if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + borderValue = alignBorderValue(this.chart.scales[positionAxisID].getPixelForValue(value)); + } + tx1 = borderValue - axisHalfWidth; + tx2 = tx1 - tl; + x1 = chartArea.left; + x2 = chartArea.right; + } + const limit = valueOrDefault(options.ticks.maxTicksLimit, ticksLength); + const step = Math.max(1, Math.ceil(ticksLength / limit)); + for (i = 0; i < ticksLength; i += step) { + const optsAtIndex = grid.setContext(this.getContext(i)); + const lineWidth = optsAtIndex.lineWidth; + const lineColor = optsAtIndex.color; + const borderDash = optsAtIndex.borderDash || []; + const borderDashOffset = optsAtIndex.borderDashOffset; + const tickWidth = optsAtIndex.tickWidth; + const tickColor = optsAtIndex.tickColor; + const tickBorderDash = optsAtIndex.tickBorderDash || []; + const tickBorderDashOffset = optsAtIndex.tickBorderDashOffset; + lineValue = getPixelForGridLine(this, i, offset); + if (lineValue === undefined) { + continue; + } + alignedLineValue = _alignPixel(chart, lineValue, lineWidth); + if (isHorizontal) { + tx1 = tx2 = x1 = x2 = alignedLineValue; + } else { + ty1 = ty2 = y1 = y2 = alignedLineValue; + } + items.push({ + tx1, + ty1, + tx2, + ty2, + x1, + y1, + x2, + y2, + width: lineWidth, + color: lineColor, + borderDash, + borderDashOffset, + tickWidth, + tickColor, + tickBorderDash, + tickBorderDashOffset, }); - } catch (ex) { - if (done) return; - done = true; - reject(self, ex); } + this._ticksLength = ticksLength; + this._borderValue = borderValue; + return items; } - Promise.prototype['catch'] = function (onRejected) { - return this.then(null, onRejected); - }; - Promise.prototype.then = function (onFulfilled, onRejected) { - const prom = new this.constructor(noop$1); - handle(this, new Handler(onFulfilled, onRejected, prom)); - return prom; - }; - Promise.prototype['finally'] = finallyConstructor; - Promise.all = function (arr) { - return new Promise(function (resolve, reject) { - if (!isArray$1(arr)) { - return reject(new TypeError('Promise.all accepts an array')); - } - const args = Array.prototype.slice.call(arr); - if (args.length === 0) return resolve([]); - let remaining = args.length; - function res(i, val) { - try { - if (val && (typeof val === 'object' || typeof val === 'function')) { - const then = val.then; - if (typeof then === 'function') { - then.call(val, function (val) { - res(i, val); - }, reject); - return; - } + _computeLabelItems(chartArea) { + const axis = this.axis; + const options = this.options; + const {position, ticks: optionTicks} = options; + const isHorizontal = this.isHorizontal(); + const ticks = this.ticks; + const {align, crossAlign, padding, mirror} = optionTicks; + const tl = getTickMarkLength(options.grid); + const tickAndPadding = tl + padding; + const hTickAndPadding = mirror ? -padding : tickAndPadding; + const rotation = -toRadians(this.labelRotation); + const items = []; + let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset; + let textBaseline = 'middle'; + if (position === 'top') { + y = this.bottom - hTickAndPadding; + textAlign = this._getXAxisLabelAlignment(); + } else if (position === 'bottom') { + y = this.top + hTickAndPadding; + textAlign = this._getXAxisLabelAlignment(); + } else if (position === 'left') { + const ret = this._getYAxisLabelAlignment(tl); + textAlign = ret.textAlign; + x = ret.x; + } else if (position === 'right') { + const ret = this._getYAxisLabelAlignment(tl); + textAlign = ret.textAlign; + x = ret.x; + } else if (axis === 'x') { + if (position === 'center') { + y = ((chartArea.top + chartArea.bottom) / 2) + tickAndPadding; + } else if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + y = this.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding; + } + textAlign = this._getXAxisLabelAlignment(); + } else if (axis === 'y') { + if (position === 'center') { + x = ((chartArea.left + chartArea.right) / 2) - tickAndPadding; + } else if (isObject(position)) { + const positionAxisID = Object.keys(position)[0]; + const value = position[positionAxisID]; + x = this.chart.scales[positionAxisID].getPixelForValue(value); + } + textAlign = this._getYAxisLabelAlignment(tl).textAlign; + } + if (axis === 'y') { + if (align === 'start') { + textBaseline = 'top'; + } else if (align === 'end') { + textBaseline = 'bottom'; + } + } + const labelSizes = this._getLabelSizes(); + for (i = 0, ilen = ticks.length; i < ilen; ++i) { + tick = ticks[i]; + label = tick.label; + const optsAtIndex = optionTicks.setContext(this.getContext(i)); + pixel = this.getPixelForTick(i) + optionTicks.labelOffset; + font = this._resolveTickFontOptions(i); + lineHeight = font.lineHeight; + lineCount = isArray(label) ? label.length : 1; + const halfCount = lineCount / 2; + const color = optsAtIndex.color; + const strokeColor = optsAtIndex.textStrokeColor; + const strokeWidth = optsAtIndex.textStrokeWidth; + let tickTextAlign = textAlign; + if (isHorizontal) { + x = pixel; + if (textAlign === 'inner') { + if (i === ilen - 1) { + tickTextAlign = !this.options.reverse ? 'right' : 'left'; + } else if (i === 0) { + tickTextAlign = !this.options.reverse ? 'left' : 'right'; + } else { + tickTextAlign = 'center'; + } + } + if (position === 'top') { + if (crossAlign === 'near' || rotation !== 0) { + textOffset = -lineCount * lineHeight + lineHeight / 2; + } else if (crossAlign === 'center') { + textOffset = -labelSizes.highest.height / 2 - halfCount * lineHeight + lineHeight; + } else { + textOffset = -labelSizes.highest.height + lineHeight / 2; } - args[i] = val; - if (--remaining === 0) { - resolve(args); + } else { + if (crossAlign === 'near' || rotation !== 0) { + textOffset = lineHeight / 2; + } else if (crossAlign === 'center') { + textOffset = labelSizes.highest.height / 2 - halfCount * lineHeight; + } else { + textOffset = labelSizes.highest.height - lineCount * lineHeight; } - } catch (ex) { - reject(ex); } + if (mirror) { + textOffset *= -1; + } + } else { + y = pixel; + textOffset = (1 - lineCount) * lineHeight / 2; + } + let backdrop; + if (optsAtIndex.showLabelBackdrop) { + const labelPadding = toPadding(optsAtIndex.backdropPadding); + const height = labelSizes.heights[i]; + const width = labelSizes.widths[i]; + let top = y + textOffset - labelPadding.top; + let left = x - labelPadding.left; + switch (textBaseline) { + case 'middle': + top -= height / 2; + break; + case 'bottom': + top -= height; + break; + } + switch (textAlign) { + case 'center': + left -= width / 2; + break; + case 'right': + left -= width; + break; + } + backdrop = { + left, + top, + width: width + labelPadding.width, + height: height + labelPadding.height, + color: optsAtIndex.backdropColor, + }; } - for (let i = 0; i < args.length; i++) { - res(i, args[i]); - } - }); - }; - Promise.allSettled = allSettled; - Promise.resolve = function (value) { - if (value && typeof value === 'object' && value.constructor === Promise) { - return value; + items.push({ + rotation, + label, + font, + color, + strokeColor, + strokeWidth, + textOffset, + textAlign: tickTextAlign, + textBaseline, + translation: [x, y], + backdrop, + }); } - return new Promise(function (resolve) { - resolve(value); - }); - }; - Promise.reject = function (value) { - return new Promise(function (resolve, reject) { - reject(value); - }); - }; - Promise.race = function (arr) { - return new Promise(function (resolve, reject) { - if (!isArray$1(arr)) { - return reject(new TypeError('Promise.race accepts an array')); - } - for (let i = 0, len = arr.length; i < len; i++) { - Promise.resolve(arr[i]).then(resolve, reject); + return items; + } + _getXAxisLabelAlignment() { + const {position, ticks} = this.options; + const rotation = -toRadians(this.labelRotation); + if (rotation) { + return position === 'top' ? 'left' : 'right'; + } + let align = 'center'; + if (ticks.align === 'start') { + align = 'left'; + } else if (ticks.align === 'end') { + align = 'right'; + } else if (ticks.align === 'inner') { + align = 'inner'; + } + return align; + } + _getYAxisLabelAlignment(tl) { + const {position, ticks: {crossAlign, mirror, padding}} = this.options; + const labelSizes = this._getLabelSizes(); + const tickAndPadding = tl + padding; + const widest = labelSizes.widest.width; + let textAlign; + let x; + if (position === 'left') { + if (mirror) { + x = this.right + padding; + if (crossAlign === 'near') { + textAlign = 'left'; + } else if (crossAlign === 'center') { + textAlign = 'center'; + x += (widest / 2); + } else { + textAlign = 'right'; + x += widest; + } + } else { + x = this.right - tickAndPadding; + if (crossAlign === 'near') { + textAlign = 'right'; + } else if (crossAlign === 'center') { + textAlign = 'center'; + x -= (widest / 2); + } else { + textAlign = 'left'; + x = this.left; + } } - }); - }; - Promise._immediateFn = - typeof setImmediate === 'function' && function (fn) { - setImmediate(fn); - } || function (fn) { - setTimeoutFunc(fn, 0); - }; - Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) { - if (typeof console !== 'undefined' && console) { - console.warn('Possible Unhandled Promise Rejection:', err); - } - }; - - var effects = { - linear: function linear(t) { - return t; - }, - easeInQuad: function easeInQuad(t) { - return t * t; - }, - easeOutQuad: function easeOutQuad(t) { - return -t * (t - 2); - }, - easeInOutQuad: function easeInOutQuad(t) { - if ((t /= 0.5) < 1) { - return 0.5 * t * t; - } - return -0.5 * (--t * (t - 2) - 1); - }, - easeInCubic: function easeInCubic(t) { - return t * t * t; - }, - easeOutCubic: function easeOutCubic(t) { - return (t -= 1) * t * t + 1; - }, - easeInOutCubic: function easeInOutCubic(t) { - if ((t /= 0.5) < 1) { - return 0.5 * t * t * t; - } - return 0.5 * ((t -= 2) * t * t + 2); - }, - easeInQuart: function easeInQuart(t) { - return t * t * t * t; - }, - easeOutQuart: function easeOutQuart(t) { - return -((t -= 1) * t * t * t - 1); - }, - easeInOutQuart: function easeInOutQuart(t) { - if ((t /= 0.5) < 1) { - return 0.5 * t * t * t * t; - } - return -0.5 * ((t -= 2) * t * t * t - 2); - }, - easeInQuint: function easeInQuint(t) { - return t * t * t * t * t; - }, - easeOutQuint: function easeOutQuint(t) { - return (t -= 1) * t * t * t * t + 1; - }, - easeInOutQuint: function easeInOutQuint(t) { - if ((t /= 0.5) < 1) { - return 0.5 * t * t * t * t * t; - } - return 0.5 * ((t -= 2) * t * t * t * t + 2); - }, - easeInSine: function easeInSine(t) { - return -Math.cos(t * HALF_PI) + 1; - }, - easeOutSine: function easeOutSine(t) { - return Math.sin(t * HALF_PI); - }, - easeInOutSine: function easeInOutSine(t) { - return -0.5 * (Math.cos(PI * t) - 1); - }, - easeInExpo: function easeInExpo(t) { - return t === 0 ? 0 : Math.pow(2, 10 * (t - 1)); - }, - easeOutExpo: function easeOutExpo(t) { - return t === 1 ? 1 : -Math.pow(2, -10 * t) + 1; - }, - easeInOutExpo: function easeInOutExpo(t) { - if (t === 0) { - return 0; - } - if (t === 1) { - return 1; - } - if ((t /= 0.5) < 1) { - return 0.5 * Math.pow(2, 10 * (t - 1)); - } - return 0.5 * (-Math.pow(2, -10 * --t) + 2); - }, - easeInCirc: function easeInCirc(t) { - if (t >= 1) { - return t; - } - return -(Math.sqrt(1 - t * t) - 1); - }, - easeOutCirc: function easeOutCirc(t) { - return Math.sqrt(1 - (t -= 1) * t); - }, - easeInOutCirc: function easeInOutCirc(t) { - if ((t /= 0.5) < 1) { - return -0.5 * (Math.sqrt(1 - t * t) - 1); - } - return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1); - }, - easeInElastic: function easeInElastic(t) { - let s = 1.70158; - let p = 0; - const a = 1; - if (t === 0) { - return 0; - } - if (t === 1) { - return 1; - } - if (!p) { - p = 0.3; - } - { - s = p / TAU * Math.asin(1 / a); - } - return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p)); - }, - easeOutElastic: function easeOutElastic(t) { - let s = 1.70158; - let p = 0; - const a = 1; - if (t === 0) { - return 0; - } - if (t === 1) { - return 1; - } - if (!p) { - p = 0.3; - } - { - s = p / TAU * Math.asin(1 / a); - } - return a * Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1; - }, - easeInOutElastic: function easeInOutElastic(t) { - let s = 1.70158; - let p = 0; - const a = 1; - if (t === 0) { - return 0; - } - if ((t /= 0.5) === 2) { - return 1; - } - if (!p) { - p = 0.45; - } - { - s = p / TAU * Math.asin(1 / a); - } - if (t < 1) { - return -0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p)); - } - return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t - s) * TAU / p) * 0.5 + 1; - }, - easeInBack: function easeInBack(t) { - const s = 1.70158; - return t * t * ((s + 1) * t - s); - }, - easeOutBack: function easeOutBack(t) { - const s = 1.70158; - return (t -= 1) * t * ((s + 1) * t + s) + 1; - }, - easeInOutBack: function easeInOutBack(t) { - let s = 1.70158; - if ((t /= 0.5) < 1) { - return 0.5 * (t * t * (((s *= 1.525) + 1) * t - s)); - } - return 0.5 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2); - }, - easeInBounce: function easeInBounce(t) { - return 1 - effects.easeOutBounce(1 - t); - }, - easeOutBounce: function easeOutBounce(t) { - if (t < 1 / 2.75) { - return 7.5625 * t * t; - } - if (t < 2 / 2.75) { - return 7.5625 * (t -= 1.5 / 2.75) * t + 0.75; - } - if (t < 2.5 / 2.75) { - return 7.5625 * (t -= 2.25 / 2.75) * t + 0.9375; - } - return 7.5625 * (t -= 2.625 / 2.75) * t + 0.984375; - }, - easeInOutBounce: function easeInOutBounce(t) { - if (t < 0.5) { - return effects.easeInBounce(t * 2) * 0.5; - } - return effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5; - } - }; - - /*! - * @kurkle/color v0.1.9 - * https://github.com/kurkle/color#readme - * (c) 2020 Jukka Kurkela - * Released under the MIT License - */ - const map = { - 0: 0, - 1: 1, - 2: 2, - 3: 3, - 4: 4, - 5: 5, - 6: 6, - 7: 7, - 8: 8, - 9: 9, - A: 10, - B: 11, - C: 12, - D: 13, - E: 14, - F: 15, - a: 10, - b: 11, - c: 12, - d: 13, - e: 14, - f: 15 - }; - const hex = '0123456789ABCDEF'; - const h1 = function h1(b) { - return hex[b & 0xF]; - }; - const h2 = function h2(b) { - return hex[(b & 0xF0) >> 4] + hex[b & 0xF]; - }; - const eq = function eq(b) { - return (b & 0xF0) >> 4 === (b & 0xF); - }; - function isShort(v) { - return eq(v.r) && eq(v.g) && eq(v.b) && eq(v.a); - } - function hexParse(str) { - const len = str.length; - let ret; - if (str[0] === '#') { - if (len === 4 || len === 5) { - ret = { - r: 255 & map[str[1]] * 17, - g: 255 & map[str[2]] * 17, - b: 255 & map[str[3]] * 17, - a: len === 5 ? map[str[4]] * 17 : 255 - }; - } else if (len === 7 || len === 9) { - ret = { - r: map[str[1]] << 4 | map[str[2]], - g: map[str[3]] << 4 | map[str[4]], - b: map[str[5]] << 4 | map[str[6]], - a: len === 9 ? map[str[7]] << 4 | map[str[8]] : 255 - }; - } - } - return ret; - } - function _hexString(v) { - const f = isShort(v) ? h1 : h2; - return v ? '#' + f(v.r) + f(v.g) + f(v.b) + (v.a < 255 ? f(v.a) : '') : v; - } - function round(v) { - return v + 0.5 | 0; - } - const lim = function lim(v, l, h) { - return Math.max(Math.min(v, h), l); - }; - function p2b(v) { - return lim(round(v * 2.55), 0, 255); - } - function n2b(v) { - return lim(round(v * 255), 0, 255); - } - function b2n(v) { - return lim(round(v / 2.55) / 100, 0, 1); - } - function n2p(v) { - return lim(round(v * 100), 0, 100); - } - const RGB_RE = /^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/; - function rgbParse(str) { - const m = RGB_RE.exec(str); - let a = 255; - let r, g, b; - if (!m) { - return; - } - if (m[7] !== r) { - const v = +m[7]; - a = 255 & (m[8] ? p2b(v) : v * 255); - } - r = +m[1]; - g = +m[3]; - b = +m[5]; - r = 255 & (m[2] ? p2b(r) : r); - g = 255 & (m[4] ? p2b(g) : g); - b = 255 & (m[6] ? p2b(b) : b); - return { - r: r, - g: g, - b: b, - a: a - }; - } - function _rgbString(v) { - return v && (v.a < 255 ? 'rgba(' + v.r + ', ' + v.g + ', ' + v.b + ', ' + b2n(v.a) + ')' : 'rgb(' + v.r + ', ' + v.g + ', ' + v.b + ')'); - } - const HUE_RE = /^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/; - function hsl2rgbn(h, s, l) { - const a = s * Math.min(l, 1 - l); - const f = function f(n, k) { - if (k === void 0) { - k = (n + h / 30) % 12; - } - return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1); - }; - return [f(0), f(8), f(4)]; - } - function hsv2rgbn(h, s, v) { - const f = function f(n, k) { - if (k === void 0) { - k = (n + h / 60) % 6; - } - return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0); - }; - return [f(5), f(3), f(1)]; - } - function hwb2rgbn(h, w, b) { - const rgb = hsl2rgbn(h, 1, 0.5); - let i; - if (w + b > 1) { - i = 1 / (w + b); - w *= i; - b *= i; - } - for (i = 0; i < 3; i++) { - rgb[i] *= 1 - w - b; - rgb[i] += w; - } - return rgb; - } - function rgb2hsl(v) { - const range = 255; - const r = v.r / range; - const g = v.g / range; - const b = v.b / range; - const max = Math.max(r, g, b); - const min = Math.min(r, g, b); - const l = (max + min) / 2; - let h, s, d; - if (max !== min) { - d = max - min; - s = l > 0.5 ? d / (2 - max - min) : d / (max + min); - h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4; - h = h * 60 + 0.5; - } - return [h | 0, s || 0, l]; - } - function calln(f, a, b, c) { - return (Array.isArray(a) ? f(a[0], a[1], a[2]) : f(a, b, c)).map(n2b); - } - function hsl2rgb(h, s, l) { - return calln(hsl2rgbn, h, s, l); - } - function hwb2rgb(h, w, b) { - return calln(hwb2rgbn, h, w, b); - } - function hsv2rgb(h, s, v) { - return calln(hsv2rgbn, h, s, v); - } - function hue(h) { - return (h % 360 + 360) % 360; - } - function hueParse(str) { - const m = HUE_RE.exec(str); - let a = 255; - let v; - if (!m) { - return; - } - if (m[5] !== v) { - a = m[6] ? p2b(+m[5]) : n2b(+m[5]); - } - const h = hue(+m[2]); - const p1 = +m[3] / 100; - const p2 = +m[4] / 100; - if (m[1] === 'hwb') { - v = hwb2rgb(h, p1, p2); - } else if (m[1] === 'hsv') { - v = hsv2rgb(h, p1, p2); - } else { - v = hsl2rgb(h, p1, p2); - } - return { - r: v[0], - g: v[1], - b: v[2], - a: a - }; - } - function _rotate(v, deg) { - let h = rgb2hsl(v); - h[0] = hue(h[0] + deg); - h = hsl2rgb(h); - v.r = h[0]; - v.g = h[1]; - v.b = h[2]; - } - function _hslString(v) { - if (!v) { - return; - } - const a = rgb2hsl(v); - const h = a[0]; - const s = n2p(a[1]); - const l = n2p(a[2]); - return v.a < 255 ? 'hsla(' + h + ', ' + s + '%, ' + l + '%, ' + b2n(v.a) + ')' : 'hsl(' + h + ', ' + s + '%, ' + l + '%)'; - } - const map$1 = { - x: 'dark', - Z: 'light', - Y: 're', - X: 'blu', - W: 'gr', - V: 'medium', - U: 'slate', - A: 'ee', - T: 'ol', - S: 'or', - B: 'ra', - C: 'lateg', - D: 'ights', - R: 'in', - Q: 'turquois', - E: 'hi', - P: 'ro', - O: 'al', - N: 'le', - M: 'de', - L: 'yello', - F: 'en', - K: 'ch', - G: 'arks', - H: 'ea', - I: 'ightg', - J: 'wh' - }; - const names = { - OiceXe: 'f0f8ff', - antiquewEte: 'faebd7', - aqua: 'ffff', - aquamarRe: '7fffd4', - azuY: 'f0ffff', - beige: 'f5f5dc', - bisque: 'ffe4c4', - black: '0', - blanKedOmond: 'ffebcd', - Xe: 'ff', - XeviTet: '8a2be2', - bPwn: 'a52a2a', - burlywood: 'deb887', - caMtXe: '5f9ea0', - KartYuse: '7fff00', - KocTate: 'd2691e', - cSO: 'ff7f50', - cSnflowerXe: '6495ed', - cSnsilk: 'fff8dc', - crimson: 'dc143c', - cyan: 'ffff', - xXe: '8b', - xcyan: '8b8b', - xgTMnPd: 'b8860b', - xWay: 'a9a9a9', - xgYF: '6400', - xgYy: 'a9a9a9', - xkhaki: 'bdb76b', - xmagFta: '8b008b', - xTivegYF: '556b2f', - xSange: 'ff8c00', - xScEd: '9932cc', - xYd: '8b0000', - xsOmon: 'e9967a', - xsHgYF: '8fbc8f', - xUXe: '483d8b', - xUWay: '2f4f4f', - xUgYy: '2f4f4f', - xQe: 'ced1', - xviTet: '9400d3', - dAppRk: 'ff1493', - dApskyXe: 'bfff', - dimWay: '696969', - dimgYy: '696969', - dodgerXe: '1e90ff', - fiYbrick: 'b22222', - flSOwEte: 'fffaf0', - foYstWAn: '228b22', - fuKsia: 'ff00ff', - gaRsbSo: 'dcdcdc', - ghostwEte: 'f8f8ff', - gTd: 'ffd700', - gTMnPd: 'daa520', - Way: '808080', - gYF: '8000', - gYFLw: 'adff2f', - gYy: '808080', - honeyMw: 'f0fff0', - hotpRk: 'ff69b4', - RdianYd: 'cd5c5c', - Rdigo: '4b0082', - ivSy: 'fffff0', - khaki: 'f0e68c', - lavFMr: 'e6e6fa', - lavFMrXsh: 'fff0f5', - lawngYF: '7cfc00', - NmoncEffon: 'fffacd', - ZXe: 'add8e6', - ZcSO: 'f08080', - Zcyan: 'e0ffff', - ZgTMnPdLw: 'fafad2', - ZWay: 'd3d3d3', - ZgYF: '90ee90', - ZgYy: 'd3d3d3', - ZpRk: 'ffb6c1', - ZsOmon: 'ffa07a', - ZsHgYF: '20b2aa', - ZskyXe: '87cefa', - ZUWay: '778899', - ZUgYy: '778899', - ZstAlXe: 'b0c4de', - ZLw: 'ffffe0', - lime: 'ff00', - limegYF: '32cd32', - lRF: 'faf0e6', - magFta: 'ff00ff', - maPon: '800000', - VaquamarRe: '66cdaa', - VXe: 'cd', - VScEd: 'ba55d3', - VpurpN: '9370db', - VsHgYF: '3cb371', - VUXe: '7b68ee', - VsprRggYF: 'fa9a', - VQe: '48d1cc', - VviTetYd: 'c71585', - midnightXe: '191970', - mRtcYam: 'f5fffa', - mistyPse: 'ffe4e1', - moccasR: 'ffe4b5', - navajowEte: 'ffdead', - navy: '80', - Tdlace: 'fdf5e6', - Tive: '808000', - TivedBb: '6b8e23', - Sange: 'ffa500', - SangeYd: 'ff4500', - ScEd: 'da70d6', - pOegTMnPd: 'eee8aa', - pOegYF: '98fb98', - pOeQe: 'afeeee', - pOeviTetYd: 'db7093', - papayawEp: 'ffefd5', - pHKpuff: 'ffdab9', - peru: 'cd853f', - pRk: 'ffc0cb', - plum: 'dda0dd', - powMrXe: 'b0e0e6', - purpN: '800080', - YbeccapurpN: '663399', - Yd: 'ff0000', - Psybrown: 'bc8f8f', - PyOXe: '4169e1', - saddNbPwn: '8b4513', - sOmon: 'fa8072', - sandybPwn: 'f4a460', - sHgYF: '2e8b57', - sHshell: 'fff5ee', - siFna: 'a0522d', - silver: 'c0c0c0', - skyXe: '87ceeb', - UXe: '6a5acd', - UWay: '708090', - UgYy: '708090', - snow: 'fffafa', - sprRggYF: 'ff7f', - stAlXe: '4682b4', - tan: 'd2b48c', - teO: '8080', - tEstN: 'd8bfd8', - tomato: 'ff6347', - Qe: '40e0d0', - viTet: 'ee82ee', - JHt: 'f5deb3', - wEte: 'ffffff', - wEtesmoke: 'f5f5f5', - Lw: 'ffff00', - LwgYF: '9acd32' - }; - function unpack() { - const unpacked = {}; - const keys = Object.keys(names); - const tkeys = Object.keys(map$1); - let i, j, k, ok, nk; - for (i = 0; i < keys.length; i++) { - ok = nk = keys[i]; - for (j = 0; j < tkeys.length; j++) { - k = tkeys[j]; - nk = nk.replace(k, map$1[k]); - } - k = parseInt(names[ok], 16); - unpacked[nk] = [k >> 16 & 0xFF, k >> 8 & 0xFF, k & 0xFF]; - } - return unpacked; - } - let names$1; - function nameParse(str) { - if (!names$1) { - names$1 = unpack(); - names$1.transparent = [0, 0, 0, 0]; - } - const a = names$1[str.toLowerCase()]; - return a && { - r: a[0], - g: a[1], - b: a[2], - a: a.length === 4 ? a[3] : 255 - }; - } - function modHSL(v, i, ratio) { - if (v) { - let tmp = rgb2hsl(v); - tmp[i] = Math.max(0, Math.min(tmp[i] + tmp[i] * ratio, i === 0 ? 360 : 1)); - tmp = hsl2rgb(tmp); - v.r = tmp[0]; - v.g = tmp[1]; - v.b = tmp[2]; - } - } - function clone$1(v, proto) { - return v ? _extends(proto || {}, v) : v; - } - function fromObject(input) { - let v = { - r: 0, - g: 0, - b: 0, - a: 255 - }; - if (Array.isArray(input)) { - if (input.length >= 3) { - v = { - r: input[0], - g: input[1], - b: input[2], - a: 255 - }; - if (input.length > 3) { - v.a = n2b(input[3]); - } - } - } else { - v = clone$1(input, { - r: 0, - g: 0, - b: 0, - a: 1 - }); - v.a = n2b(v.a); - } - return v; - } - function functionParse(str) { - if (str.charAt(0) === 'r') { - return rgbParse(str); - } - return hueParse(str); - } - const Color = function () { - function Color(input) { - if (input instanceof Color) { - return input; - } - const type = typeof input; - let v; - if (type === 'object') { - v = fromObject(input); - } else if (type === 'string') { - v = hexParse(input) || nameParse(input) || functionParse(input); - } - this._rgb = v; - this._valid = !!v; - } - const _proto = Color.prototype; - _proto.rgbString = function rgbString() { - return this._valid ? _rgbString(this._rgb) : this._rgb; - }; - _proto.hexString = function hexString() { - return this._valid ? _hexString(this._rgb) : this._rgb; - }; - _proto.hslString = function hslString() { - return this._valid ? _hslString(this._rgb) : this._rgb; - }; - _proto.mix = function mix(color, weight) { - const me = this; - if (color) { - const c1 = me.rgb; - const c2 = color.rgb; - let w2; - const p = weight === w2 ? 0.5 : weight; - const w = 2 * p - 1; - const a = c1.a - c2.a; - const w1 = ((w * a === -1 ? w : (w + a) / (1 + w * a)) + 1) / 2.0; - w2 = 1 - w1; - c1.r = 0xFF & w1 * c1.r + w2 * c2.r + 0.5; - c1.g = 0xFF & w1 * c1.g + w2 * c2.g + 0.5; - c1.b = 0xFF & w1 * c1.b + w2 * c2.b + 0.5; - c1.a = p * c1.a + (1 - p) * c2.a; - me.rgb = c1; - } - return me; - }; - _proto.clone = function clone() { - return new Color(this.rgb); - }; - _proto.alpha = function alpha(a) { - this._rgb.a = n2b(a); - return this; - }; - _proto.clearer = function clearer(ratio) { - const rgb = this._rgb; - rgb.a *= 1 - ratio; - return this; - }; - _proto.greyscale = function greyscale() { - const rgb = this._rgb; - const val = round(rgb.r * 0.3 + rgb.g * 0.59 + rgb.b * 0.11); - rgb.r = rgb.g = rgb.b = val; - return this; - }; - _proto.opaquer = function opaquer(ratio) { - const rgb = this._rgb; - rgb.a *= 1 + ratio; - return this; - }; - _proto.negate = function negate() { - const v = this._rgb; - v.r = 255 - v.r; - v.g = 255 - v.g; - v.b = 255 - v.b; - return this; - }; - _proto.lighten = function lighten(ratio) { - modHSL(this._rgb, 2, ratio); - return this; - }; - _proto.darken = function darken(ratio) { - modHSL(this._rgb, 2, -ratio); - return this; - }; - _proto.saturate = function saturate(ratio) { - modHSL(this._rgb, 1, ratio); - return this; - }; - _proto.desaturate = function desaturate(ratio) { - modHSL(this._rgb, 1, -ratio); - return this; - }; - _proto.rotate = function rotate(deg) { - _rotate(this._rgb, deg); - return this; - }; - _createClass(Color, [{ - key: 'valid', - get: function get() { - return this._valid; - } - }, { - key: 'rgb', - get: function get() { - const v = clone$1(this._rgb); - if (v) { - v.a = b2n(v.a); - } - return v; - }, - set: function set(obj) { - this._rgb = fromObject(obj); - } - }]); - return Color; - }(); - function index_esm(input) { - return new Color(input); - } - - const isPatternOrGradient = function isPatternOrGradient(value) { - return value instanceof CanvasGradient || value instanceof CanvasPattern; - }; - function color(value) { - return isPatternOrGradient(value) ? value : index_esm(value); - } - function getHoverColor(value) { - return isPatternOrGradient(value) ? value : index_esm(value).saturate(0.5).darken(0.1).hexString(); - } - - const transparent = 'transparent'; - const interpolators = { - boolean: function boolean(from, to, factor) { - return factor > 0.5 ? to : from; - }, - color: function color$1(from, to, factor) { - const c0 = color(from || transparent); - const c1 = c0.valid && color(to || transparent); - return c1 && c1.valid ? c1.mix(c0, factor).hexString() : to; - }, - number: function number(from, to, factor) { - return from + (to - from) * factor; - } - }; - const Animation = function () { - function Animation(cfg, target, prop, to) { - const currentValue = target[prop]; - to = resolve([cfg.to, to, currentValue, cfg.from]); - const from = resolve([cfg.from, currentValue, to]); - this._active = true; - this._fn = cfg.fn || interpolators[cfg.type || typeof from]; - this._easing = effects[cfg.easing || 'linear']; - this._start = Math.floor(Date.now() + (cfg.delay || 0)); - this._duration = Math.floor(cfg.duration); - this._loop = !!cfg.loop; - this._target = target; - this._prop = prop; - this._from = from; - this._to = to; - this._promises = undefined; - } - const _proto = Animation.prototype; - _proto.active = function active() { - return this._active; - }; - _proto.update = function update(cfg, to, date) { - const me = this; - if (me._active) { - const currentValue = me._target[me._prop]; - const elapsed = date - me._start; - const remain = me._duration - elapsed; - me._start = date; - me._duration = Math.floor(Math.max(remain, cfg.duration)); - me._loop = !!cfg.loop; - me._to = resolve([cfg.to, to, currentValue, cfg.from]); - me._from = resolve([cfg.from, currentValue, to]); - } - }; - _proto.cancel = function cancel() { - const me = this; - if (me._active) { - me.tick(Date.now()); - me._active = false; - me._notify(false); - } - }; - _proto.tick = function tick(date) { - const me = this; - const elapsed = date - me._start; - const duration = me._duration; - const prop = me._prop; - const from = me._from; - const loop = me._loop; - const to = me._to; - let factor; - me._active = from !== to && (loop || elapsed < duration); - if (!me._active) { - me._target[prop] = to; - me._notify(true); - return; - } - if (elapsed < 0) { - me._target[prop] = from; - return; - } - factor = elapsed / duration % 2; - factor = loop && factor > 1 ? 2 - factor : factor; - factor = me._easing(Math.min(1, Math.max(0, factor))); - me._target[prop] = me._fn(from, to, factor); - }; - _proto.wait = function wait() { - const promises = this._promises || (this._promises = []); - return new Promise(function (res, rej) { - promises.push({ - res: res, - rej: rej - }); - }); - }; - _proto._notify = function _notify(resolved) { - const method = resolved ? 'res' : 'rej'; - const promises = this._promises || []; - for (let i = 0; i < promises.length; i++) { - promises[i][method](); - } - }; - return Animation; - }(); - - const numbers = ['x', 'y', 'borderWidth', 'radius', 'tension']; - const colors = ['borderColor', 'backgroundColor']; - defaults.set('animation', { - duration: 1000, - easing: 'easeOutQuart', - onProgress: noop, - onComplete: noop, - colors: { - type: 'color', - properties: colors - }, - numbers: { - type: 'number', - properties: numbers - }, - active: { - duration: 400 - }, - resize: { - duration: 0 - }, - show: { - colors: { - type: 'color', - properties: colors, - from: 'transparent' - }, - visible: { - type: 'boolean', - duration: 0 - } - }, - hide: { - colors: { - type: 'color', - properties: colors, - to: 'transparent' - }, - visible: { - type: 'boolean', - easing: 'easeInExpo' - } - } - }); - function copyOptions(target, values) { - const oldOpts = target.options; - const newOpts = values.options; - if (!oldOpts || !newOpts) { - return; - } - if (oldOpts.$shared && !newOpts.$shared) { - target.options = _extends({}, oldOpts, newOpts, { - $shared: false - }); - } else { - _extends(oldOpts, newOpts); - } - delete values.options; - } - function extensibleConfig(animations) { - const result = {}; - Object.keys(animations).forEach(function (key) { - const value = animations[key]; - if (!isObject(value)) { - result[key] = value; - } - }); - return result; - } - const Animations = function () { - function Animations(chart, animations) { - this._chart = chart; - this._properties = new Map(); - this.configure(animations); - } - const _proto = Animations.prototype; - _proto.configure = function configure(animations) { - if (!isObject(animations)) { - return; - } - const animatedProps = this._properties; - const animDefaults = extensibleConfig(animations); - Object.keys(animations).forEach(function (key) { - const cfg = animations[key]; - if (!isObject(cfg)) { - return; - } - (cfg.properties || [key]).forEach(function (prop) { - if (!animatedProps.has(prop)) { - animatedProps.set(prop, _extends({}, animDefaults, cfg)); - } else if (prop === key) { - const _animatedProps$get = animatedProps.get(prop), - properties = _animatedProps$get.properties, - inherited = _objectWithoutPropertiesLoose(_animatedProps$get, ['properties']); - animatedProps.set(prop, _extends({}, inherited, cfg)); - } - }); - }); - } - ; - _proto._animateOptions = function _animateOptions(target, values) { - const newOptions = values.options; - const options = resolveTargetOptions(target, newOptions); - if (!options) { - return []; - } - const animations = this._createAnimations(options, newOptions); - if (newOptions.$shared && !options.$shared) { - awaitAll(target.options.$animations, newOptions).then(function () { - target.options = newOptions; - }); - } - return animations; - } - ; - _proto._createAnimations = function _createAnimations(target, values) { - const animatedProps = this._properties; - const animations = []; - const running = target.$animations || (target.$animations = {}); - const props = Object.keys(values); - const date = Date.now(); - let i; - for (i = props.length - 1; i >= 0; --i) { - const prop = props[i]; - if (prop.charAt(0) === '$') { - continue; - } - if (prop === 'options') { - animations.push.apply(animations, this._animateOptions(target, values)); - continue; - } - const value = values[prop]; - let animation = running[prop]; - const cfg = animatedProps.get(prop); - if (animation) { - if (cfg && animation.active()) { - animation.update(cfg, value, date); - continue; - } else { - animation.cancel(); - } - } - if (!cfg || !cfg.duration) { - target[prop] = value; - continue; - } - running[prop] = animation = new Animation(cfg, target, prop, value); - animations.push(animation); - } - return animations; - } - ; - _proto.update = function update(target, values) { - if (this._properties.size === 0) { - copyOptions(target, values); - _extends(target, values); - return; - } - const animations = this._createAnimations(target, values); - if (animations.length) { - animator.add(this._chart, animations); - return true; - } - }; - return Animations; - }(); - function awaitAll(animations, properties) { - const running = []; - const keys = Object.keys(properties); - for (let i = 0; i < keys.length; i++) { - const anim = animations[keys[i]]; - if (anim && anim.active()) { - running.push(anim.wait()); - } - } - return Promise.all(running); - } - function resolveTargetOptions(target, newOptions) { - if (!newOptions) { - return; - } - let options = target.options; - if (!options) { - target.options = newOptions; - return; - } - if (options.$shared && !newOptions.$shared) { - target.options = options = _extends({}, options, { - $shared: false, - $animations: {} - }); - } - return options; - } - - function scaleClip(scale, allowedOverflow) { - const opts = scale && scale.options || {}; - const reverse = opts.reverse; - const min = opts.min === undefined ? allowedOverflow : 0; - const max = opts.max === undefined ? allowedOverflow : 0; - return { - start: reverse ? max : min, - end: reverse ? min : max - }; - } - function defaultClip(xScale, yScale, allowedOverflow) { - if (allowedOverflow === false) { - return false; - } - const x = scaleClip(xScale, allowedOverflow); - const y = scaleClip(yScale, allowedOverflow); - return { - top: y.end, - right: x.end, - bottom: y.start, - left: x.start - }; - } - function toClip(value) { - let t, r, b, l; - if (isObject(value)) { - t = value.top; - r = value.right; - b = value.bottom; - l = value.left; - } else { - t = r = b = l = value; - } - return { - top: t, - right: r, - bottom: b, - left: l - }; - } - function getSortedDatasetIndices(chart, filterVisible) { - const keys = []; - const metasets = chart._getSortedDatasetMetas(filterVisible); - let i, ilen; - for (i = 0, ilen = metasets.length; i < ilen; ++i) { - keys.push(metasets[i].index); - } - return keys; - } - function _applyStack(stack, value, dsIndex, allOther) { - const keys = stack.keys; - let i, ilen, datasetIndex, otherValue; - for (i = 0, ilen = keys.length; i < ilen; ++i) { - datasetIndex = +keys[i]; - if (datasetIndex === dsIndex) { - if (allOther) { - continue; - } - break; - } - otherValue = stack.values[datasetIndex]; - if (!isNaN(otherValue) && (value === 0 || sign(value) === sign(otherValue))) { - value += otherValue; - } - } - return value; - } - function convertObjectDataToArray(data) { - const keys = Object.keys(data); - const adata = new Array(keys.length); - let i, ilen, key; - for (i = 0, ilen = keys.length; i < ilen; ++i) { - key = keys[i]; - adata[i] = { - x: key, - y: data[key] - }; - } - return adata; - } - function isStacked(scale, meta) { - const stacked = scale && scale.options.stacked; - return stacked || stacked === undefined && meta.stack !== undefined; - } - function getStackKey(indexScale, valueScale, meta) { - return indexScale.id + '.' + valueScale.id + '.' + meta.stack + '.' + meta.type; - } - function getUserBounds(scale) { - const _scale$getUserBounds = scale.getUserBounds(), - min = _scale$getUserBounds.min, - max = _scale$getUserBounds.max, - minDefined = _scale$getUserBounds.minDefined, - maxDefined = _scale$getUserBounds.maxDefined; - return { - min: minDefined ? min : Number.NEGATIVE_INFINITY, - max: maxDefined ? max : Number.POSITIVE_INFINITY - }; - } - function getOrCreateStack(stacks, stackKey, indexValue) { - const subStack = stacks[stackKey] || (stacks[stackKey] = {}); - return subStack[indexValue] || (subStack[indexValue] = {}); - } - function updateStacks(controller, parsed) { - const chart = controller.chart, - meta = controller._cachedMeta; - const stacks = chart._stacks || (chart._stacks = {}); - const iScale = meta.iScale, - vScale = meta.vScale, - datasetIndex = meta.index; - const iAxis = iScale.axis; - const vAxis = vScale.axis; - const key = getStackKey(iScale, vScale, meta); - const ilen = parsed.length; - let stack; - for (let i = 0; i < ilen; ++i) { - const item = parsed[i]; - const index = item[iAxis], - value = item[vAxis]; - const itemStacks = item._stacks || (item._stacks = {}); - stack = itemStacks[vAxis] = getOrCreateStack(stacks, key, index); - stack[datasetIndex] = value; - } - } - function getFirstScaleId(chart, axis) { - const scales = chart.scales; - return Object.keys(scales).filter(function (key) { - return scales[key].axis === axis; - }).shift(); - } - function createDatasetContext(parent, index, dataset) { - return Object.create(parent, { - active: { - writable: true, - value: false - }, - dataset: { - value: dataset - }, - datasetIndex: { - value: index - }, - index: { - get: function get() { - return this.datasetIndex; - } - }, - type: { - value: 'dataset' - } - }); - } - function createDataContext(parent, index, point, element) { - return Object.create(parent, { - active: { - writable: true, - value: false - }, - dataIndex: { - value: index - }, - dataPoint: { - value: point - }, - element: { - value: element - }, - index: { - get: function get() { - return this.dataIndex; - } - }, - type: { - value: 'data' - } - }); - } - function clearStacks(meta, items) { - items = items || meta._parsed; - items.forEach(function (parsed) { - delete parsed._stacks[meta.vScale.id][meta.index]; - }); - } - const optionKeys = function optionKeys(optionNames) { - return isArray(optionNames) ? optionNames : Object.keys(optionNames); - }; - const optionKey = function optionKey(key, active) { - return active ? 'hover' + _capitalize(key) : key; - }; - const isDirectUpdateMode = function isDirectUpdateMode(mode) { - return mode === 'reset' || mode === 'none'; - }; - const cloneIfNotShared = function cloneIfNotShared(cached, shared) { - return shared ? cached : _extends({}, cached); - }; - const freezeIfShared = function freezeIfShared(values, shared) { - return shared ? Object.freeze(values) : values; - }; - const DatasetController = function () { - function DatasetController(chart, datasetIndex) { - this.chart = chart; - this._ctx = chart.ctx; - this.index = datasetIndex; - this._cachedAnimations = {}; - this._cachedDataOpts = {}; - this._cachedMeta = this.getMeta(); - this._type = this._cachedMeta.type; - this._config = undefined; - this._parsing = false; - this._data = undefined; - this._objectData = undefined; - this._sharedOptions = undefined; - this._drawStart = undefined; - this._drawCount = undefined; - this.enableOptionSharing = false; - this.$context = undefined; - this.initialize(); - } - const _proto = DatasetController.prototype; - _proto.initialize = function initialize() { - const me = this; - const meta = me._cachedMeta; - me.configure(); - me.linkScales(); - meta._stacked = isStacked(meta.vScale, meta); - me.addElements(); - }; - _proto.updateIndex = function updateIndex(datasetIndex) { - this.index = datasetIndex; - }; - _proto.linkScales = function linkScales() { - const me = this; - const chart = me.chart; - const meta = me._cachedMeta; - const dataset = me.getDataset(); - const chooseId = function chooseId(axis, x, y, r) { - return axis === 'x' ? x : axis === 'r' ? r : y; - }; - const xid = meta.xAxisID = valueOrDefault(dataset.xAxisID, getFirstScaleId(chart, 'x')); - const yid = meta.yAxisID = valueOrDefault(dataset.yAxisID, getFirstScaleId(chart, 'y')); - const rid = meta.rAxisID = valueOrDefault(dataset.rAxisID, getFirstScaleId(chart, 'r')); - const indexAxis = meta.indexAxis; - const iid = meta.iAxisID = chooseId(indexAxis, xid, yid, rid); - const vid = meta.vAxisID = chooseId(indexAxis, yid, xid, rid); - meta.xScale = me.getScaleForId(xid); - meta.yScale = me.getScaleForId(yid); - meta.rScale = me.getScaleForId(rid); - meta.iScale = me.getScaleForId(iid); - meta.vScale = me.getScaleForId(vid); - }; - _proto.getDataset = function getDataset() { - return this.chart.data.datasets[this.index]; - }; - _proto.getMeta = function getMeta() { - return this.chart.getDatasetMeta(this.index); - } - ; - _proto.getScaleForId = function getScaleForId(scaleID) { - return this.chart.scales[scaleID]; - } - ; - _proto._getOtherScale = function _getOtherScale(scale) { - const meta = this._cachedMeta; - return scale === meta.iScale ? meta.vScale : meta.iScale; - }; - _proto.reset = function reset() { - this._update('reset'); - } - ; - _proto._destroy = function _destroy() { - const meta = this._cachedMeta; - if (this._data) { - unlistenArrayEvents(this._data, this); - } - if (meta._stacked) { - clearStacks(meta); - } - } - ; - _proto._dataCheck = function _dataCheck() { - const me = this; - const dataset = me.getDataset(); - const data = dataset.data || (dataset.data = []); - if (isObject(data)) { - me._data = convertObjectDataToArray(data); - } else if (me._data !== data) { - if (me._data) { - unlistenArrayEvents(me._data, me); - } - if (data && Object.isExtensible(data)) { - listenArrayEvents(data, me); - } - me._data = data; - } - }; - _proto.addElements = function addElements() { - const me = this; - const meta = me._cachedMeta; - me._dataCheck(); - const data = me._data; - const metaData = meta.data = new Array(data.length); - for (let i = 0, ilen = data.length; i < ilen; ++i) { - metaData[i] = new me.dataElementType(); - } - if (me.datasetElementType) { - meta.dataset = new me.datasetElementType(); - } - }; - _proto.buildOrUpdateElements = function buildOrUpdateElements() { - const me = this; - const meta = me._cachedMeta; - const dataset = me.getDataset(); - let stackChanged = false; - me._dataCheck(); - meta._stacked = isStacked(meta.vScale, meta); - if (meta.stack !== dataset.stack) { - stackChanged = true; - clearStacks(meta); - meta.stack = dataset.stack; - } - me._resyncElements(); - if (stackChanged) { - updateStacks(me, meta._parsed); - } - } - ; - _proto.configure = function configure() { - const me = this; - me._config = merge(Object.create(null), [defaults.controllers[me._type].datasets, (me.chart.options[me._type] || {}).datasets, me.getDataset()], { - merger: function merger(key, target, source) { - if (key !== 'data') { - _merger(key, target, source); - } - } - }); - me._parsing = resolve([me._config.parsing, me.chart.options.parsing, true]); - } - ; - _proto.parse = function parse(start, count) { - const me = this; - const meta = me._cachedMeta, - data = me._data; - const iScale = meta.iScale, - vScale = meta.vScale, - _stacked = meta._stacked; - const iAxis = iScale.axis; - let sorted = true; - let i, parsed, cur, prev; - if (start > 0) { - sorted = meta._sorted; - prev = meta._parsed[start - 1]; - } - if (me._parsing === false) { - meta._parsed = data; - meta._sorted = true; - } else { - if (isArray(data[start])) { - parsed = me.parseArrayData(meta, data, start, count); - } else if (isObject(data[start])) { - parsed = me.parseObjectData(meta, data, start, count); - } else { - parsed = me.parsePrimitiveData(meta, data, start, count); - } - const isNotInOrderComparedToPrev = function isNotInOrderComparedToPrev() { - return isNaN(cur[iAxis]) || prev && cur[iAxis] < prev[iAxis]; - }; - for (i = 0; i < count; ++i) { - meta._parsed[i + start] = cur = parsed[i]; - if (sorted) { - if (isNotInOrderComparedToPrev()) { - sorted = false; - } - prev = cur; - } - } - meta._sorted = sorted; - } - if (_stacked) { - updateStacks(me, parsed); - } - iScale.invalidateCaches(); - vScale.invalidateCaches(); - } - ; - _proto.parsePrimitiveData = function parsePrimitiveData(meta, data, start, count) { - const iScale = meta.iScale, - vScale = meta.vScale; - const iAxis = iScale.axis; - const vAxis = vScale.axis; - const labels = iScale.getLabels(); - const singleScale = iScale === vScale; - const parsed = new Array(count); - let i, ilen, index; - for (i = 0, ilen = count; i < ilen; ++i) { - var _parsed$i; - index = i + start; - parsed[i] = (_parsed$i = {}, _parsed$i[iAxis] = singleScale || iScale.parse(labels[index], index), _parsed$i[vAxis] = vScale.parse(data[index], index), _parsed$i); - } - return parsed; - } - ; - _proto.parseArrayData = function parseArrayData(meta, data, start, count) { - const xScale = meta.xScale, - yScale = meta.yScale; - const parsed = new Array(count); - let i, ilen, index, item; - for (i = 0, ilen = count; i < ilen; ++i) { - index = i + start; - item = data[index]; - parsed[i] = { - x: xScale.parse(item[0], index), - y: yScale.parse(item[1], index) - }; - } - return parsed; - } - ; - _proto.parseObjectData = function parseObjectData(meta, data, start, count) { - const xScale = meta.xScale, - yScale = meta.yScale; - const _this$_parsing = this._parsing, - _this$_parsing$xAxisK = _this$_parsing.xAxisKey, - xAxisKey = _this$_parsing$xAxisK === void 0 ? 'x' : _this$_parsing$xAxisK, - _this$_parsing$yAxisK = _this$_parsing.yAxisKey, - yAxisKey = _this$_parsing$yAxisK === void 0 ? 'y' : _this$_parsing$yAxisK; - const parsed = new Array(count); - let i, ilen, index, item; - for (i = 0, ilen = count; i < ilen; ++i) { - index = i + start; - item = data[index]; - parsed[i] = { - x: xScale.parse(resolveObjectKey(item, xAxisKey), index), - y: yScale.parse(resolveObjectKey(item, yAxisKey), index) - }; - } - return parsed; - } - ; - _proto.getParsed = function getParsed(index) { - return this._cachedMeta._parsed[index]; - } - ; - _proto.getDataElement = function getDataElement(index) { - return this._cachedMeta.data[index]; - } - ; - _proto.applyStack = function applyStack(scale, parsed) { - const chart = this.chart; - const meta = this._cachedMeta; - const value = parsed[scale.axis]; - const stack = { - keys: getSortedDatasetIndices(chart, true), - values: parsed._stacks[scale.axis] - }; - return _applyStack(stack, value, meta.index); - } - ; - _proto.updateRangeFromParsed = function updateRangeFromParsed(range, scale, parsed, stack) { - let value = parsed[scale.axis]; - const values = stack && parsed._stacks[scale.axis]; - if (stack && values) { - stack.values = values; - range.min = Math.min(range.min, value); - range.max = Math.max(range.max, value); - value = _applyStack(stack, value, this._cachedMeta.index, true); - } - range.min = Math.min(range.min, value); - range.max = Math.max(range.max, value); - } - ; - _proto.getMinMax = function getMinMax(scale, canStack) { - const me = this; - const meta = me._cachedMeta; - const _parsed = meta._parsed; - const sorted = meta._sorted && scale === meta.iScale; - const ilen = _parsed.length; - const otherScale = me._getOtherScale(scale); - const stack = canStack && meta._stacked && { - keys: getSortedDatasetIndices(me.chart, true), - values: null - }; - const range = { - min: Number.POSITIVE_INFINITY, - max: Number.NEGATIVE_INFINITY - }; - const _getUserBounds = getUserBounds(otherScale), - otherMin = _getUserBounds.min, - otherMax = _getUserBounds.max; - let i, value, parsed, otherValue; - function _skip() { - parsed = _parsed[i]; - value = parsed[scale.axis]; - otherValue = parsed[otherScale.axis]; - return isNaN(value) || isNaN(otherValue) || otherMin > otherValue || otherMax < otherValue; - } - for (i = 0; i < ilen; ++i) { - if (_skip()) { - continue; - } - me.updateRangeFromParsed(range, scale, parsed, stack); - if (sorted) { - break; - } - } - if (sorted) { - for (i = ilen - 1; i >= 0; --i) { - if (_skip()) { - continue; - } - me.updateRangeFromParsed(range, scale, parsed, stack); - break; - } - } - return range; - }; - _proto.getAllParsedValues = function getAllParsedValues(scale) { - const parsed = this._cachedMeta._parsed; - const values = []; - let i, ilen, value; - for (i = 0, ilen = parsed.length; i < ilen; ++i) { - value = parsed[i][scale.axis]; - if (!isNaN(value)) { - values.push(value); - } - } - return values; - } - ; - _proto.getMaxOverflow = function getMaxOverflow() { - return false; - } - ; - _proto.getLabelAndValue = function getLabelAndValue(index) { - const me = this; - const meta = me._cachedMeta; - const iScale = meta.iScale; - const vScale = meta.vScale; - const parsed = me.getParsed(index); - return { - label: iScale ? '' + iScale.getLabelForValue(parsed[iScale.axis]) : '', - value: vScale ? '' + vScale.getLabelForValue(parsed[vScale.axis]) : '' - }; - } - ; - _proto._update = function _update(mode) { - const me = this; - const meta = me._cachedMeta; - me.configure(); - me._cachedAnimations = {}; - me._cachedDataOpts = {}; - me.update(mode || 'default'); - meta._clip = toClip(valueOrDefault(me._config.clip, defaultClip(meta.xScale, meta.yScale, me.getMaxOverflow()))); - } - ; - _proto.update = function update(mode) {} - ; - _proto.draw = function draw() { - const me = this; - const ctx = me._ctx; - const chart = me.chart; - const meta = me._cachedMeta; - const elements = meta.data || []; - const area = chart.chartArea; - const active = []; - const start = me._drawStart || 0; - const count = me._drawCount || elements.length - start; - let i; - if (meta.dataset) { - meta.dataset.draw(ctx, area, start, count); - } - for (i = start; i < start + count; ++i) { - const element = elements[i]; - if (element.active) { - active.push(element); - } else { - element.draw(ctx, area); - } - } - for (i = 0; i < active.length; ++i) { - active[i].draw(ctx, area); - } - } - ; - _proto._addAutomaticHoverColors = function _addAutomaticHoverColors(index, options) { - const me = this; - const normalOptions = me.getStyle(index); - const missingColors = Object.keys(normalOptions).filter(function (key) { - return key.indexOf('Color') !== -1 && !(key in options); - }); - let i = missingColors.length - 1; - let color; - for (; i >= 0; i--) { - color = missingColors[i]; - options[color] = getHoverColor(normalOptions[color]); - } - } - ; - _proto.getStyle = function getStyle(index, active) { - const me = this; - const meta = me._cachedMeta; - const dataset = meta.dataset; - if (!me._config) { - me.configure(); - } - const options = dataset && index === undefined ? me.resolveDatasetElementOptions(active) : me.resolveDataElementOptions(index || 0, active && 'active'); - if (active) { - me._addAutomaticHoverColors(index, options); - } - return options; - } - ; - _proto.getContext = function getContext(index, active) { - const me = this; - let context; - if (index >= 0 && index < me._cachedMeta.data.length) { - const element = me._cachedMeta.data[index]; - context = element.$context || (element.$context = createDataContext(me.getContext(), index, me.getParsed(index), element)); - } else { - context = me.$context || (me.$context = createDatasetContext(me.chart.getContext(), me.index, me.getDataset())); - } - context.active = !!active; - return context; - } - ; - _proto.resolveDatasetElementOptions = function resolveDatasetElementOptions(active) { - return this._resolveOptions(this.datasetElementOptions, { - active: active, - type: this.datasetElementType.id - }); - } - ; - _proto.resolveDataElementOptions = function resolveDataElementOptions(index, mode) { - mode = mode || 'default'; - const me = this; - const active = mode === 'active'; - const cache = me._cachedDataOpts; - const cached = cache[mode]; - const sharing = me.enableOptionSharing; - if (cached) { - return cloneIfNotShared(cached, sharing); - } - const info = { - cacheable: !active - }; - const values = me._resolveOptions(me.dataElementOptions, { - index: index, - active: active, - info: info, - type: me.dataElementType.id - }); - if (info.cacheable) { - values.$shared = sharing; - cache[mode] = freezeIfShared(values, sharing); - } - return values; - } - ; - _proto._resolveOptions = function _resolveOptions(optionNames, args) { - const me = this; - const index = args.index, - active = args.active, - type = args.type, - info = args.info; - const datasetOpts = me._config; - const options = me.chart.options.elements[type] || {}; - const values = {}; - const context = me.getContext(index, active); - const keys = optionKeys(optionNames); - for (let i = 0, ilen = keys.length; i < ilen; ++i) { - const key = keys[i]; - const readKey = optionKey(key, active); - const value = resolve([datasetOpts[optionNames[readKey]], datasetOpts[readKey], options[readKey]], context, index, info); - if (value !== undefined) { - values[key] = value; - } - } - return values; - } - ; - _proto._resolveAnimations = function _resolveAnimations(index, mode, active) { - const me = this; - const chart = me.chart; - const cached = me._cachedAnimations; - mode = mode || 'default'; - if (cached[mode]) { - return cached[mode]; - } - const info = { - cacheable: true - }; - const context = me.getContext(index, active); - const chartAnim = resolve([chart.options.animation], context, index, info); - const datasetAnim = resolve([me._config.animation], context, index, info); - let config = chartAnim && mergeIf({}, [datasetAnim, chartAnim]); - if (config[mode]) { - config = _extends({}, config, config[mode]); - } - const animations = new Animations(chart, config); - if (info.cacheable) { - cached[mode] = animations && Object.freeze(animations); - } - return animations; - } - ; - _proto.getSharedOptions = function getSharedOptions(options) { - if (!options.$shared) { - return; - } - return this._sharedOptions || (this._sharedOptions = _extends({}, options)); - } - ; - _proto.includeOptions = function includeOptions(mode, sharedOptions) { - return !sharedOptions || isDirectUpdateMode(mode); - } - ; - _proto.updateElement = function updateElement(element, index, properties, mode) { - if (isDirectUpdateMode(mode)) { - _extends(element, properties); - } else { - this._resolveAnimations(index, mode).update(element, properties); - } - } - ; - _proto.updateSharedOptions = function updateSharedOptions(sharedOptions, mode, newOptions) { - if (sharedOptions) { - this._resolveAnimations(undefined, mode).update({ - options: sharedOptions - }, { - options: newOptions - }); - } - } - ; - _proto._setStyle = function _setStyle(element, index, mode, active) { - element.active = active; - const options = this.getStyle(index, active); - this._resolveAnimations(index, mode, active).update(element, { - options: this.getSharedOptions(options) || options - }); - }; - _proto.removeHoverStyle = function removeHoverStyle(element, datasetIndex, index) { - this._setStyle(element, index, 'active', false); - }; - _proto.setHoverStyle = function setHoverStyle(element, datasetIndex, index) { - this._setStyle(element, index, 'active', true); - } - ; - _proto._removeDatasetHoverStyle = function _removeDatasetHoverStyle() { - const element = this._cachedMeta.dataset; - if (element) { - this._setStyle(element, undefined, 'active', false); - } - } - ; - _proto._setDatasetHoverStyle = function _setDatasetHoverStyle() { - const element = this._cachedMeta.dataset; - if (element) { - this._setStyle(element, undefined, 'active', true); - } - } - ; - _proto._resyncElements = function _resyncElements() { - const me = this; - const numMeta = me._cachedMeta.data.length; - const numData = me._data.length; - if (numData > numMeta) { - me._insertElements(numMeta, numData - numMeta); - } else if (numData < numMeta) { - me._removeElements(numData, numMeta - numData); - } - me.parse(0, Math.min(numData, numMeta)); - } - ; - _proto._insertElements = function _insertElements(start, count) { - const me = this; - const elements = new Array(count); - const meta = me._cachedMeta; - const data = meta.data; - let i; - for (i = 0; i < count; ++i) { - elements[i] = new me.dataElementType(); - } - data.splice.apply(data, [start, 0].concat(elements)); - if (me._parsing) { - let _meta$_parsed; - (_meta$_parsed = meta._parsed).splice.apply(_meta$_parsed, [start, 0].concat(new Array(count))); - } - me.parse(start, count); - me.updateElements(data, start, count, 'reset'); - }; - _proto.updateElements = function updateElements(element, start, count, mode) {} - ; - _proto._removeElements = function _removeElements(start, count) { - const me = this; - const meta = me._cachedMeta; - if (me._parsing) { - const removed = meta._parsed.splice(start, count); - if (meta._stacked) { - clearStacks(meta, removed); - } - } - meta.data.splice(start, count); - } - ; - _proto._onDataPush = function _onDataPush() { - const count = arguments.length; - this._insertElements(this.getDataset().data.length - count, count); - } - ; - _proto._onDataPop = function _onDataPop() { - this._removeElements(this._cachedMeta.data.length - 1, 1); - } - ; - _proto._onDataShift = function _onDataShift() { - this._removeElements(0, 1); - } - ; - _proto._onDataSplice = function _onDataSplice(start, count) { - this._removeElements(start, count); - this._insertElements(start, arguments.length - 2); - } - ; - _proto._onDataUnshift = function _onDataUnshift() { - this._insertElements(0, arguments.length); - }; - return DatasetController; - }(); - DatasetController.defaults = {}; - DatasetController.prototype.datasetElementType = null; - DatasetController.prototype.dataElementType = null; - DatasetController.prototype.datasetElementOptions = ['backgroundColor', 'borderCapStyle', 'borderColor', 'borderDash', 'borderDashOffset', 'borderJoinStyle', 'borderWidth']; - DatasetController.prototype.dataElementOptions = ['backgroundColor', 'borderColor', 'borderWidth', 'pointStyle']; - - const Element$1 = function () { - function Element() { - this.x = undefined; - this.y = undefined; - this.active = false; - this.options = undefined; - this.$animations = undefined; - } - const _proto = Element.prototype; - _proto.tooltipPosition = function tooltipPosition(useFinalPosition) { - const _this$getProps = this.getProps(['x', 'y'], useFinalPosition), - x = _this$getProps.x, - y = _this$getProps.y; - return { - x: x, - y: y - }; - }; - _proto.hasValue = function hasValue() { - return isNumber(this.x) && isNumber(this.y); - } - ; - _proto.getProps = function getProps(props, final) { - const me = this; - const anims = this.$animations; - if (!final || !anims) { - return me; - } - const ret = {}; - props.forEach(function (prop) { - ret[prop] = anims[prop] && anims[prop].active ? anims[prop]._to : me[prop]; - }); - return ret; - }; - return Element; - }(); - Element$1.defaults = {}; - Element$1.defaultRoutes = undefined; - - const intlCache = new Map(); - const formatters = { - values: function values(value) { - return isArray(value) ? value : '' + value; - }, - numeric: function numeric(tickValue, index, ticks) { - if (tickValue === 0) { - return '0'; - } - const locale = this.chart.options.locale; - const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value)); - let notation; - if (maxTick < 1e-4 || maxTick > 1e+15) { - notation = 'scientific'; - } - let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value; - if (Math.abs(delta) > 1 && tickValue !== Math.floor(tickValue)) { - delta = tickValue - Math.floor(tickValue); - } - const logDelta = log10(Math.abs(delta)); - const numDecimal = Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0); - const options = { - notation: notation, - minimumFractionDigits: numDecimal, - maximumFractionDigits: numDecimal - }; - _extends(options, this.options.ticks.format); - const cacheKey = locale + JSON.stringify(options); - let formatter = intlCache.get(cacheKey); - if (!formatter) { - formatter = new Intl.NumberFormat(locale, options); - intlCache.set(cacheKey, formatter); - } - return formatter.format(tickValue); - } - }; - formatters.logarithmic = function (tickValue, index, ticks) { - if (tickValue === 0) { - return '0'; - } - const remain = tickValue / Math.pow(10, Math.floor(log10(tickValue))); - if (remain === 1 || remain === 2 || remain === 5) { - return formatters.numeric.call(this, tickValue, index, ticks); - } - return ''; - }; - const Ticks = { - formatters: formatters - }; - - defaults.set('scale', { - display: true, - offset: false, - reverse: false, - beginAtZero: false, - gridLines: { - display: true, - color: 'rgba(0,0,0,0.1)', - lineWidth: 1, - drawBorder: true, - drawOnChartArea: true, - drawTicks: true, - tickMarkLength: 10, - offsetGridLines: false, - borderDash: [], - borderDashOffset: 0.0 - }, - scaleLabel: { - display: false, - labelString: '', - padding: { - top: 4, - bottom: 4 - } - }, - ticks: { - minRotation: 0, - maxRotation: 50, - mirror: false, - lineWidth: 0, - strokeStyle: '', - padding: 0, - display: true, - autoSkip: true, - autoSkipPadding: 0, - labelOffset: 0, - callback: Ticks.formatters.values, - minor: {}, - major: {}, - align: 'center', - crossAlign: 'near' - } - }); - function sample(arr, numItems) { - const result = []; - const increment = arr.length / numItems; - const len = arr.length; - let i = 0; - for (; i < len; i += increment) { - result.push(arr[Math.floor(i)]); - } - return result; - } - function getPixelForGridLine(scale, index, offsetGridLines) { - const length = scale.ticks.length; - const validIndex = Math.min(index, length - 1); - const start = scale._startPixel; - const end = scale._endPixel; - const epsilon = 1e-6; - let lineValue = scale.getPixelForTick(validIndex); - let offset; - if (offsetGridLines) { - if (length === 1) { - offset = Math.max(lineValue - start, end - lineValue); - } else if (index === 0) { - offset = (scale.getPixelForTick(1) - lineValue) / 2; - } else { - offset = (lineValue - scale.getPixelForTick(validIndex - 1)) / 2; - } - lineValue += validIndex < index ? offset : -offset; - if (lineValue < start - epsilon || lineValue > end + epsilon) { - return; - } - } - return lineValue; - } - function garbageCollect(caches, length) { - each(caches, function (cache) { - const gc = cache.gc; - const gcLen = gc.length / 2; - let i; - if (gcLen > length) { - for (i = 0; i < gcLen; ++i) { - delete cache.data[gc[i]]; - } - gc.splice(0, gcLen); - } - }); - } - function getTickMarkLength(options) { - return options.drawTicks ? options.tickMarkLength : 0; - } - function getScaleLabelHeight(options, fallback) { - if (!options.display) { - return 0; - } - const font = toFont(options.font, fallback); - const padding = toPadding(options.padding); - return font.lineHeight + padding.height; - } - function getEvenSpacing(arr) { - const len = arr.length; - let i, diff; - if (len < 2) { - return false; - } - for (diff = arr[0], i = 1; i < len; ++i) { - if (arr[i] - arr[i - 1] !== diff) { - return false; - } - } - return diff; - } - function calculateSpacing(majorIndices, ticks, ticksLimit) { - const evenMajorSpacing = getEvenSpacing(majorIndices); - const spacing = ticks.length / ticksLimit; - if (!evenMajorSpacing) { - return Math.max(spacing, 1); - } - const factors = _factorize(evenMajorSpacing); - for (let i = 0, ilen = factors.length - 1; i < ilen; i++) { - const factor = factors[i]; - if (factor > spacing) { - return factor; - } - } - return Math.max(spacing, 1); - } - function getMajorIndices(ticks) { - const result = []; - let i, ilen; - for (i = 0, ilen = ticks.length; i < ilen; i++) { - if (ticks[i].major) { - result.push(i); - } - } - return result; - } - function skipMajors(ticks, newTicks, majorIndices, spacing) { - let count = 0; - let next = majorIndices[0]; - let i; - spacing = Math.ceil(spacing); - for (i = 0; i < ticks.length; i++) { - if (i === next) { - newTicks.push(ticks[i]); - count++; - next = majorIndices[count * spacing]; - } - } - } - function skip(ticks, newTicks, spacing, majorStart, majorEnd) { - const start = valueOrDefault(majorStart, 0); - const end = Math.min(valueOrDefault(majorEnd, ticks.length), ticks.length); - let count = 0; - let length, i, next; - spacing = Math.ceil(spacing); - if (majorEnd) { - length = majorEnd - majorStart; - spacing = length / Math.floor(length / spacing); - } - next = start; - while (next < 0) { - count++; - next = Math.round(start + count * spacing); - } - for (i = Math.max(start, 0); i < end; i++) { - if (i === next) { - newTicks.push(ticks[i]); - count++; - next = Math.round(start + count * spacing); - } - } - } - function createScaleContext(parent, scale) { - return Object.create(parent, { - scale: { - value: scale - }, - type: { - value: 'scale' - } - }); - } - function createTickContext(parent, index, tick) { - return Object.create(parent, { - tick: { - value: tick - }, - index: { - value: index - }, - type: { - value: 'tick' - } - }); - } - const Scale = function (_Element) { - _inheritsLoose(Scale, _Element); - function Scale(cfg) { - let _this; - _this = _Element.call(this) || this; - _this.id = cfg.id; - _this.type = cfg.type; - _this.options = undefined; - _this.ctx = cfg.ctx; - _this.chart = cfg.chart; - _this.top = undefined; - _this.bottom = undefined; - _this.left = undefined; - _this.right = undefined; - _this.width = undefined; - _this.height = undefined; - _this._margins = { - left: 0, - right: 0, - top: 0, - bottom: 0 - }; - _this.maxWidth = undefined; - _this.maxHeight = undefined; - _this.paddingTop = undefined; - _this.paddingBottom = undefined; - _this.paddingLeft = undefined; - _this.paddingRight = undefined; - _this.axis = undefined; - _this.labelRotation = undefined; - _this.min = undefined; - _this.max = undefined; - _this.ticks = []; - _this._gridLineItems = null; - _this._labelItems = null; - _this._labelSizes = null; - _this._length = 0; - _this._longestTextCache = {}; - _this._startPixel = undefined; - _this._endPixel = undefined; - _this._reversePixels = false; - _this._userMax = undefined; - _this._userMin = undefined; - _this._ticksLength = 0; - _this._borderValue = 0; - _this._cache = {}; - _this.$context = undefined; - return _this; - } - const _proto = Scale.prototype; - _proto.init = function init(options) { - const me = this; - me.options = options; - me.axis = me.isHorizontal() ? 'x' : 'y'; - me._userMin = me.parse(options.min); - me._userMax = me.parse(options.max); - } - ; - _proto.parse = function parse(raw, index) { - return raw; - } - ; - _proto.getUserBounds = function getUserBounds() { - let min = this._userMin; - let max = this._userMax; - if (isNullOrUndef(min) || isNaN(min)) { - min = Number.POSITIVE_INFINITY; - } - if (isNullOrUndef(max) || isNaN(max)) { - max = Number.NEGATIVE_INFINITY; - } - return { - min: min, - max: max, - minDefined: isNumberFinite(min), - maxDefined: isNumberFinite(max) - }; - } - ; - _proto.getMinMax = function getMinMax(canStack) { - const me = this; - let _me$getUserBounds = me.getUserBounds(), - min = _me$getUserBounds.min, - max = _me$getUserBounds.max, - minDefined = _me$getUserBounds.minDefined, - maxDefined = _me$getUserBounds.maxDefined; - let range; - if (minDefined && maxDefined) { - return { - min: min, - max: max - }; - } - const metas = me.getMatchingVisibleMetas(); - for (let i = 0, ilen = metas.length; i < ilen; ++i) { - range = metas[i].controller.getMinMax(me, canStack); - if (!minDefined) { - min = Math.min(min, range.min); - } - if (!maxDefined) { - max = Math.max(max, range.max); - } - } - return { - min: min, - max: max - }; - }; - _proto.invalidateCaches = function invalidateCaches() { - this._cache = {}; - } - ; - _proto.getPadding = function getPadding() { - const me = this; - return { - left: me.paddingLeft || 0, - top: me.paddingTop || 0, - right: me.paddingRight || 0, - bottom: me.paddingBottom || 0 - }; - } - ; - _proto.getTicks = function getTicks() { - return this.ticks; - } - ; - _proto.getLabels = function getLabels() { - const data = this.chart.data; - return this.options.labels || (this.isHorizontal() ? data.xLabels : data.yLabels) || data.labels || []; - } - ; - _proto.beforeUpdate = function beforeUpdate() { - callback(this.options.beforeUpdate, [this]); - } - ; - _proto.update = function update(maxWidth, maxHeight, margins) { - const me = this; - const tickOpts = me.options.ticks; - const sampleSize = tickOpts.sampleSize; - me.beforeUpdate(); - me.maxWidth = maxWidth; - me.maxHeight = maxHeight; - me._margins = _extends({ - left: 0, - right: 0, - top: 0, - bottom: 0 - }, margins); - me.ticks = null; - me._labelSizes = null; - me._gridLineItems = null; - me._labelItems = null; - me.beforeSetDimensions(); - me.setDimensions(); - me.afterSetDimensions(); - me.beforeDataLimits(); - me.determineDataLimits(); - me.afterDataLimits(); - me.beforeBuildTicks(); - me.ticks = me.buildTicks() || []; - me.afterBuildTicks(); - const samplingEnabled = sampleSize < me.ticks.length; - me._convertTicksToLabels(samplingEnabled ? sample(me.ticks, sampleSize) : me.ticks); - me.configure(); - me.beforeCalculateLabelRotation(); - me.calculateLabelRotation(); - me.afterCalculateLabelRotation(); - me.beforeFit(); - me.fit(); - me.afterFit(); - me.ticks = tickOpts.display && (tickOpts.autoSkip || tickOpts.source === 'auto') ? me._autoSkip(me.ticks) : me.ticks; - if (samplingEnabled) { - me._convertTicksToLabels(me.ticks); - } - me.afterUpdate(); - } - ; - _proto.configure = function configure() { - const me = this; - let reversePixels = me.options.reverse; - let startPixel, endPixel; - if (me.isHorizontal()) { - startPixel = me.left; - endPixel = me.right; - } else { - startPixel = me.top; - endPixel = me.bottom; - reversePixels = !reversePixels; - } - me._startPixel = startPixel; - me._endPixel = endPixel; - me._reversePixels = reversePixels; - me._length = endPixel - startPixel; - }; - _proto.afterUpdate = function afterUpdate() { - callback(this.options.afterUpdate, [this]); - } - ; - _proto.beforeSetDimensions = function beforeSetDimensions() { - callback(this.options.beforeSetDimensions, [this]); - }; - _proto.setDimensions = function setDimensions() { - const me = this; - if (me.isHorizontal()) { - me.width = me.maxWidth; - me.left = 0; - me.right = me.width; - } else { - me.height = me.maxHeight; - me.top = 0; - me.bottom = me.height; - } - me.paddingLeft = 0; - me.paddingTop = 0; - me.paddingRight = 0; - me.paddingBottom = 0; - }; - _proto.afterSetDimensions = function afterSetDimensions() { - callback(this.options.afterSetDimensions, [this]); - } - ; - _proto.beforeDataLimits = function beforeDataLimits() { - callback(this.options.beforeDataLimits, [this]); - }; - _proto.determineDataLimits = function determineDataLimits() {}; - _proto.afterDataLimits = function afterDataLimits() { - callback(this.options.afterDataLimits, [this]); - } - ; - _proto.beforeBuildTicks = function beforeBuildTicks() { - callback(this.options.beforeBuildTicks, [this]); - } - ; - _proto.buildTicks = function buildTicks() { - return []; - }; - _proto.afterBuildTicks = function afterBuildTicks() { - callback(this.options.afterBuildTicks, [this]); - }; - _proto.beforeTickToLabelConversion = function beforeTickToLabelConversion() { - callback(this.options.beforeTickToLabelConversion, [this]); - } - ; - _proto.generateTickLabels = function generateTickLabels(ticks) { - const me = this; - const tickOpts = me.options.ticks; - let i, ilen, tick; - for (i = 0, ilen = ticks.length; i < ilen; i++) { - tick = ticks[i]; - tick.label = callback(tickOpts.callback, [tick.value, i, ticks], me); - } - }; - _proto.afterTickToLabelConversion = function afterTickToLabelConversion() { - callback(this.options.afterTickToLabelConversion, [this]); - } - ; - _proto.beforeCalculateLabelRotation = function beforeCalculateLabelRotation() { - callback(this.options.beforeCalculateLabelRotation, [this]); - }; - _proto.calculateLabelRotation = function calculateLabelRotation() { - const me = this; - const options = me.options; - const tickOpts = options.ticks; - const numTicks = me.ticks.length; - const minRotation = tickOpts.minRotation || 0; - const maxRotation = tickOpts.maxRotation; - let labelRotation = minRotation; - let tickWidth, maxHeight, maxLabelDiagonal; - if (!me._isVisible() || !tickOpts.display || minRotation >= maxRotation || numTicks <= 1 || !me.isHorizontal()) { - me.labelRotation = minRotation; - return; - } - const labelSizes = me._getLabelSizes(); - const maxLabelWidth = labelSizes.widest.width; - const maxLabelHeight = labelSizes.highest.height - labelSizes.highest.offset; - const maxWidth = Math.min(me.maxWidth, me.chart.width - maxLabelWidth); - tickWidth = options.offset ? me.maxWidth / numTicks : maxWidth / (numTicks - 1); - if (maxLabelWidth + 6 > tickWidth) { - tickWidth = maxWidth / (numTicks - (options.offset ? 0.5 : 1)); - maxHeight = me.maxHeight - getTickMarkLength(options.gridLines) - tickOpts.padding - getScaleLabelHeight(options.scaleLabel, me.chart.options.font); - maxLabelDiagonal = Math.sqrt(maxLabelWidth * maxLabelWidth + maxLabelHeight * maxLabelHeight); - labelRotation = toDegrees(Math.min(Math.asin(Math.min((labelSizes.highest.height + 6) / tickWidth, 1)), Math.asin(Math.min(maxHeight / maxLabelDiagonal, 1)) - Math.asin(maxLabelHeight / maxLabelDiagonal))); - labelRotation = Math.max(minRotation, Math.min(maxRotation, labelRotation)); - } - me.labelRotation = labelRotation; - }; - _proto.afterCalculateLabelRotation = function afterCalculateLabelRotation() { - callback(this.options.afterCalculateLabelRotation, [this]); - } - ; - _proto.beforeFit = function beforeFit() { - callback(this.options.beforeFit, [this]); - }; - _proto.fit = function fit() { - const me = this; - const minSize = { - width: 0, - height: 0 - }; - const chart = me.chart; - const opts = me.options; - const tickOpts = opts.ticks; - const scaleLabelOpts = opts.scaleLabel; - const gridLineOpts = opts.gridLines; - const display = me._isVisible(); - const labelsBelowTicks = opts.position !== 'top' && me.axis === 'x'; - const isHorizontal = me.isHorizontal(); - const scaleLabelHeight = display && getScaleLabelHeight(scaleLabelOpts, chart.options.font); - if (isHorizontal) { - minSize.width = me.maxWidth; - } else if (display) { - minSize.width = getTickMarkLength(gridLineOpts) + scaleLabelHeight; - } - if (!isHorizontal) { - minSize.height = me.maxHeight; - } else if (display) { - minSize.height = getTickMarkLength(gridLineOpts) + scaleLabelHeight; - } - if (tickOpts.display && display && me.ticks.length) { - const labelSizes = me._getLabelSizes(); - const firstLabelSize = labelSizes.first; - const lastLabelSize = labelSizes.last; - const widestLabelSize = labelSizes.widest; - const highestLabelSize = labelSizes.highest; - const lineSpace = highestLabelSize.offset * 0.8; - const tickPadding = tickOpts.padding; - if (isHorizontal) { - const isRotated = me.labelRotation !== 0; - const angleRadians = toRadians(me.labelRotation); - const cosRotation = Math.cos(angleRadians); - const sinRotation = Math.sin(angleRadians); - const labelHeight = sinRotation * widestLabelSize.width + cosRotation * (highestLabelSize.height - (isRotated ? highestLabelSize.offset : 0)) + (isRotated ? 0 : lineSpace); - minSize.height = Math.min(me.maxHeight, minSize.height + labelHeight + tickPadding); - const offsetLeft = me.getPixelForTick(0) - me.left; - const offsetRight = me.right - me.getPixelForTick(me.ticks.length - 1); - let paddingLeft, paddingRight; - if (isRotated) { - paddingLeft = labelsBelowTicks ? cosRotation * firstLabelSize.width + sinRotation * firstLabelSize.offset : sinRotation * (firstLabelSize.height - firstLabelSize.offset); - paddingRight = labelsBelowTicks ? sinRotation * (lastLabelSize.height - lastLabelSize.offset) : cosRotation * lastLabelSize.width + sinRotation * lastLabelSize.offset; - } else if (tickOpts.align === 'start') { - paddingLeft = 0; - paddingRight = lastLabelSize.width; - } else if (tickOpts.align === 'end') { - paddingLeft = firstLabelSize.width; - paddingRight = 0; - } else { - paddingLeft = firstLabelSize.width / 2; - paddingRight = lastLabelSize.width / 2; - } - me.paddingLeft = Math.max((paddingLeft - offsetLeft) * me.width / (me.width - offsetLeft), 0) + 3; - me.paddingRight = Math.max((paddingRight - offsetRight) * me.width / (me.width - offsetRight), 0) + 3; - } else { - const labelWidth = tickOpts.mirror ? 0 : - widestLabelSize.width + tickPadding + lineSpace; - minSize.width = Math.min(me.maxWidth, minSize.width + labelWidth); - let paddingTop = lastLabelSize.height / 2; - let paddingBottom = firstLabelSize.height / 2; - if (tickOpts.align === 'start') { - paddingTop = 0; - paddingBottom = firstLabelSize.height; - } else if (tickOpts.align === 'end') { - paddingTop = lastLabelSize.height; - paddingBottom = 0; - } - me.paddingTop = paddingTop; - me.paddingBottom = paddingBottom; - } - } - me._handleMargins(); - if (isHorizontal) { - me.width = me._length = chart.width - me._margins.left - me._margins.right; - me.height = minSize.height; - } else { - me.width = minSize.width; - me.height = me._length = chart.height - me._margins.top - me._margins.bottom; - } - } - ; - _proto._handleMargins = function _handleMargins() { - const me = this; - if (me._margins) { - me._margins.left = Math.max(me.paddingLeft, me._margins.left); - me._margins.top = Math.max(me.paddingTop, me._margins.top); - me._margins.right = Math.max(me.paddingRight, me._margins.right); - me._margins.bottom = Math.max(me.paddingBottom, me._margins.bottom); - } - }; - _proto.afterFit = function afterFit() { - callback(this.options.afterFit, [this]); - } - ; - _proto.isHorizontal = function isHorizontal() { - const _this$options = this.options, - axis = _this$options.axis, - position = _this$options.position; - return position === 'top' || position === 'bottom' || axis === 'x'; - } - ; - _proto.isFullWidth = function isFullWidth() { - return this.options.fullWidth; - } - ; - _proto._convertTicksToLabels = function _convertTicksToLabels(ticks) { - const me = this; - me.beforeTickToLabelConversion(); - me.generateTickLabels(ticks); - me.afterTickToLabelConversion(); - } - ; - _proto._getLabelSizes = function _getLabelSizes() { - const me = this; - let labelSizes = me._labelSizes; - if (!labelSizes) { - me._labelSizes = labelSizes = me._computeLabelSizes(); - } - return labelSizes; - } - ; - _proto._computeLabelSizes = function _computeLabelSizes() { - const me = this; - const ctx = me.ctx; - const caches = me._longestTextCache; - const sampleSize = me.options.ticks.sampleSize; - const widths = []; - const heights = []; - const offsets = []; - let widestLabelSize = 0; - let highestLabelSize = 0; - let ticks = me.ticks; - if (sampleSize < ticks.length) { - ticks = sample(ticks, sampleSize); - } - const length = ticks.length; - let i, j, jlen, label, tickFont, fontString, cache, lineHeight, width, height, nestedLabel; - for (i = 0; i < length; ++i) { - label = ticks[i].label; - tickFont = me._resolveTickFontOptions(i); - ctx.font = fontString = tickFont.string; - cache = caches[fontString] = caches[fontString] || { - data: {}, - gc: [] - }; - lineHeight = tickFont.lineHeight; - width = height = 0; - if (!isNullOrUndef(label) && !isArray(label)) { - width = _measureText(ctx, cache.data, cache.gc, width, label); - height = lineHeight; - } else if (isArray(label)) { - for (j = 0, jlen = label.length; j < jlen; ++j) { - nestedLabel = label[j]; - if (!isNullOrUndef(nestedLabel) && !isArray(nestedLabel)) { - width = _measureText(ctx, cache.data, cache.gc, width, nestedLabel); - height += lineHeight; - } - } - } - widths.push(width); - heights.push(height); - offsets.push(lineHeight / 2); - widestLabelSize = Math.max(width, widestLabelSize); - highestLabelSize = Math.max(height, highestLabelSize); - } - garbageCollect(caches, length); - const widest = widths.indexOf(widestLabelSize); - const highest = heights.indexOf(highestLabelSize); - function valueAt(idx) { - return { - width: widths[idx] || 0, - height: heights[idx] || 0, - offset: offsets[idx] || 0 - }; - } - return { - first: valueAt(0), - last: valueAt(length - 1), - widest: valueAt(widest), - highest: valueAt(highest) - }; - } - ; - _proto.getLabelForValue = function getLabelForValue(value) { - return value; - } - ; - _proto.getPixelForValue = function getPixelForValue(value, index) { - return NaN; - } - ; - _proto.getValueForPixel = function getValueForPixel(pixel) {} - ; - _proto.getPixelForTick = function getPixelForTick(index) { - const ticks = this.ticks; - if (index < 0 || index > ticks.length - 1) { - return null; - } - return this.getPixelForValue(ticks[index].value); - } - ; - _proto.getPixelForDecimal = function getPixelForDecimal(decimal) { - const me = this; - if (me._reversePixels) { - decimal = 1 - decimal; - } - return _int16Range(me._startPixel + decimal * me._length); - } - ; - _proto.getDecimalForPixel = function getDecimalForPixel(pixel) { - const decimal = (pixel - this._startPixel) / this._length; - return this._reversePixels ? 1 - decimal : decimal; - } - ; - _proto.getBasePixel = function getBasePixel() { - return this.getPixelForValue(this.getBaseValue()); - } - ; - _proto.getBaseValue = function getBaseValue() { - const min = this.min, - max = this.max; - return min < 0 && max < 0 ? max : min > 0 && max > 0 ? min : 0; - } - ; - _proto.getContext = function getContext(index) { - const me = this; - const ticks = me.ticks || []; - if (index >= 0 && index < ticks.length) { - const tick = ticks[index]; - return tick.$context || (tick.$context = createTickContext(me.getContext(), index, tick)); - } - return me.$context || (me.$context = createScaleContext(me.chart.getContext(), me)); - } - ; - _proto._autoSkip = function _autoSkip(ticks) { - const me = this; - const tickOpts = me.options.ticks; - const ticksLimit = tickOpts.maxTicksLimit || me._length / me._tickSize(); - const majorIndices = tickOpts.major.enabled ? getMajorIndices(ticks) : []; - const numMajorIndices = majorIndices.length; - const first = majorIndices[0]; - const last = majorIndices[numMajorIndices - 1]; - const newTicks = []; - if (numMajorIndices > ticksLimit) { - skipMajors(ticks, newTicks, majorIndices, numMajorIndices / ticksLimit); - return newTicks; - } - const spacing = calculateSpacing(majorIndices, ticks, ticksLimit); - if (numMajorIndices > 0) { - let i, ilen; - const avgMajorSpacing = numMajorIndices > 1 ? Math.round((last - first) / (numMajorIndices - 1)) : null; - skip(ticks, newTicks, spacing, isNullOrUndef(avgMajorSpacing) ? 0 : first - avgMajorSpacing, first); - for (i = 0, ilen = numMajorIndices - 1; i < ilen; i++) { - skip(ticks, newTicks, spacing, majorIndices[i], majorIndices[i + 1]); - } - skip(ticks, newTicks, spacing, last, isNullOrUndef(avgMajorSpacing) ? ticks.length : last + avgMajorSpacing); - return newTicks; - } - skip(ticks, newTicks, spacing); - return newTicks; - } - ; - _proto._tickSize = function _tickSize() { - const me = this; - const optionTicks = me.options.ticks; - const rot = toRadians(me.labelRotation); - const cos = Math.abs(Math.cos(rot)); - const sin = Math.abs(Math.sin(rot)); - const labelSizes = me._getLabelSizes(); - const padding = optionTicks.autoSkipPadding || 0; - const w = labelSizes ? labelSizes.widest.width + padding : 0; - const h = labelSizes ? labelSizes.highest.height + padding : 0; - return me.isHorizontal() ? h * cos > w * sin ? w / cos : h / sin : h * sin < w * cos ? h / cos : w / sin; - } - ; - _proto._isVisible = function _isVisible() { - const display = this.options.display; - if (display !== 'auto') { - return !!display; - } - return this.getMatchingVisibleMetas().length > 0; - } - ; - _proto._computeGridLineItems = function _computeGridLineItems(chartArea) { - const me = this; - const axis = me.axis; - const chart = me.chart; - const options = me.options; - const gridLines = options.gridLines, - position = options.position; - const offsetGridLines = gridLines.offsetGridLines; - const isHorizontal = me.isHorizontal(); - const ticks = me.ticks; - const ticksLength = ticks.length + (offsetGridLines ? 1 : 0); - const tl = getTickMarkLength(gridLines); - const items = []; - let context = this.getContext(0); - const axisWidth = gridLines.drawBorder ? resolve([gridLines.borderWidth, gridLines.lineWidth, 0], context, 0) : 0; - const axisHalfWidth = axisWidth / 2; - const alignBorderValue = function alignBorderValue(pixel) { - return _alignPixel(chart, pixel, axisWidth); - }; - let borderValue, i, lineValue, alignedLineValue; - let tx1, ty1, tx2, ty2, x1, y1, x2, y2; - if (position === 'top') { - borderValue = alignBorderValue(me.bottom); - ty1 = me.bottom - tl; - ty2 = borderValue - axisHalfWidth; - y1 = alignBorderValue(chartArea.top) + axisHalfWidth; - y2 = chartArea.bottom; - } else if (position === 'bottom') { - borderValue = alignBorderValue(me.top); - y1 = chartArea.top; - y2 = alignBorderValue(chartArea.bottom) - axisHalfWidth; - ty1 = borderValue + axisHalfWidth; - ty2 = me.top + tl; - } else if (position === 'left') { - borderValue = alignBorderValue(me.right); - tx1 = me.right - tl; - tx2 = borderValue - axisHalfWidth; - x1 = alignBorderValue(chartArea.left) + axisHalfWidth; - x2 = chartArea.right; - } else if (position === 'right') { - borderValue = alignBorderValue(me.left); - x1 = chartArea.left; - x2 = alignBorderValue(chartArea.right) - axisHalfWidth; - tx1 = borderValue + axisHalfWidth; - tx2 = me.left + tl; - } else if (axis === 'x') { - if (position === 'center') { - borderValue = alignBorderValue((chartArea.top + chartArea.bottom) / 2); - } else if (isObject(position)) { - const positionAxisID = Object.keys(position)[0]; - const value = position[positionAxisID]; - borderValue = alignBorderValue(me.chart.scales[positionAxisID].getPixelForValue(value)); - } - y1 = chartArea.top; - y2 = chartArea.bottom; - ty1 = borderValue + axisHalfWidth; - ty2 = ty1 + tl; - } else if (axis === 'y') { - if (position === 'center') { - borderValue = alignBorderValue((chartArea.left + chartArea.right) / 2); - } else if (isObject(position)) { - const _positionAxisID = Object.keys(position)[0]; - const _value = position[_positionAxisID]; - borderValue = alignBorderValue(me.chart.scales[_positionAxisID].getPixelForValue(_value)); - } - tx1 = borderValue - axisHalfWidth; - tx2 = tx1 - tl; - x1 = chartArea.left; - x2 = chartArea.right; - } - for (i = 0; i < ticksLength; ++i) { - context = this.getContext(i); - const lineWidth = resolve([gridLines.lineWidth], context, i); - const lineColor = resolve([gridLines.color], context, i); - const borderDash = gridLines.borderDash || []; - const borderDashOffset = resolve([gridLines.borderDashOffset], context, i); - lineValue = getPixelForGridLine(me, i, offsetGridLines); - if (lineValue === undefined) { - continue; - } - alignedLineValue = _alignPixel(chart, lineValue, lineWidth); - if (isHorizontal) { - tx1 = tx2 = x1 = x2 = alignedLineValue; - } else { - ty1 = ty2 = y1 = y2 = alignedLineValue; - } - items.push({ - tx1: tx1, - ty1: ty1, - tx2: tx2, - ty2: ty2, - x1: x1, - y1: y1, - x2: x2, - y2: y2, - width: lineWidth, - color: lineColor, - borderDash: borderDash, - borderDashOffset: borderDashOffset - }); - } - me._ticksLength = ticksLength; - me._borderValue = borderValue; - return items; - } - ; - _proto._computeLabelItems = function _computeLabelItems(chartArea) { - const me = this; - const axis = me.axis; - const options = me.options; - const position = options.position, - optionTicks = options.ticks; - const isHorizontal = me.isHorizontal(); - const ticks = me.ticks; - const align = optionTicks.align, - crossAlign = optionTicks.crossAlign, - padding = optionTicks.padding; - const tl = getTickMarkLength(options.gridLines); - const tickAndPadding = tl + padding; - const rotation = -toRadians(me.labelRotation); - const items = []; - let i, ilen, tick, label, x, y, textAlign, pixel, font, lineHeight, lineCount, textOffset; - let textBaseline = 'middle'; - if (position === 'top') { - y = me.bottom - tickAndPadding; - textAlign = me._getXAxisLabelAlignment(); - } else if (position === 'bottom') { - y = me.top + tickAndPadding; - textAlign = me._getXAxisLabelAlignment(); - } else if (position === 'left') { - const ret = this._getYAxisLabelAlignment(tl); - textAlign = ret.textAlign; - x = ret.x; - } else if (position === 'right') { - const _ret = this._getYAxisLabelAlignment(tl); - textAlign = _ret.textAlign; - x = _ret.x; - } else if (axis === 'x') { - if (position === 'center') { - y = (chartArea.top + chartArea.bottom) / 2 + tickAndPadding; - } else if (isObject(position)) { - const positionAxisID = Object.keys(position)[0]; - const value = position[positionAxisID]; - y = me.chart.scales[positionAxisID].getPixelForValue(value) + tickAndPadding; - } - textAlign = me._getXAxisLabelAlignment(); - } else if (axis === 'y') { - if (position === 'center') { - x = (chartArea.left + chartArea.right) / 2 - tickAndPadding; - } else if (isObject(position)) { - const _positionAxisID2 = Object.keys(position)[0]; - const _value2 = position[_positionAxisID2]; - x = me.chart.scales[_positionAxisID2].getPixelForValue(_value2); - } - textAlign = this._getYAxisLabelAlignment(tl).textAlign; - } - if (axis === 'y') { - if (align === 'start') { - textBaseline = 'top'; - } else if (align === 'end') { - textBaseline = 'bottom'; - } - } - const labelSizes = me._getLabelSizes(); - for (i = 0, ilen = ticks.length; i < ilen; ++i) { - tick = ticks[i]; - label = tick.label; - pixel = me.getPixelForTick(i) + optionTicks.labelOffset; - font = me._resolveTickFontOptions(i); - lineHeight = font.lineHeight; - lineCount = isArray(label) ? label.length : 1; - const halfCount = lineCount / 2; - if (isHorizontal) { - x = pixel; - if (position === 'top') { - if (crossAlign === 'near' || rotation !== 0) { - textOffset = (Math.sin(rotation) * halfCount + 0.5) * lineHeight; - textOffset -= (rotation === 0 ? lineCount - 0.5 : Math.cos(rotation) * halfCount) * lineHeight; - } else if (crossAlign === 'center') { - textOffset = -1 * (labelSizes.highest.height / 2); - textOffset -= halfCount * lineHeight; - } else { - textOffset = -1 * labelSizes.highest.height + 0.5 * lineHeight; - } - } else if (position === 'bottom') { - if (crossAlign === 'near' || rotation !== 0) { - textOffset = Math.sin(rotation) * halfCount * lineHeight; - textOffset += (rotation === 0 ? 0.5 : Math.cos(rotation) * halfCount) * lineHeight; - } else if (crossAlign === 'center') { - textOffset = labelSizes.highest.height / 2; - textOffset -= halfCount * lineHeight; - } else { - textOffset = labelSizes.highest.height - (lineCount - 0.5) * lineHeight; - } - } - } else { - y = pixel; - textOffset = (1 - lineCount) * lineHeight / 2; - } - items.push({ - x: x, - y: y, - rotation: rotation, - label: label, - font: font, - textOffset: textOffset, - textAlign: textAlign, - textBaseline: textBaseline - }); - } - return items; - }; - _proto._getXAxisLabelAlignment = function _getXAxisLabelAlignment() { - const me = this; - const _me$options = me.options, - position = _me$options.position, - ticks = _me$options.ticks; - const rotation = -toRadians(me.labelRotation); - if (rotation) { - return position === 'top' ? 'left' : 'right'; - } - let align = 'center'; - if (ticks.align === 'start') { - align = 'left'; - } else if (ticks.align === 'end') { - align = 'right'; - } - return align; - }; - _proto._getYAxisLabelAlignment = function _getYAxisLabelAlignment(tl) { - const me = this; - const _me$options2 = me.options, - position = _me$options2.position, - ticks = _me$options2.ticks; - const crossAlign = ticks.crossAlign, - mirror = ticks.mirror, - padding = ticks.padding; - const labelSizes = me._getLabelSizes(); - const tickAndPadding = tl + padding; - const widest = labelSizes.widest.width; - let textAlign; - let x; - if (position === 'left') { - if (mirror) { - textAlign = 'left'; - x = me.right - padding; - } else { - x = me.right - tickAndPadding; - if (crossAlign === 'near') { - textAlign = 'right'; - } else if (crossAlign === 'center') { - textAlign = 'center'; - x -= widest / 2; - } else { - textAlign = 'left'; - x -= widest; - } - } - } else if (position === 'right') { - if (mirror) { - textAlign = 'right'; - x = me.left + padding; - } else { - x = me.left + tickAndPadding; - if (crossAlign === 'near') { - textAlign = 'left'; - } else if (crossAlign === 'center') { - textAlign = 'center'; - x += widest / 2; - } else { - textAlign = 'right'; - x += widest; - } - } - } else { - textAlign = 'right'; - } - return { - textAlign: textAlign, - x: x - }; - } - ; - _proto.drawGrid = function drawGrid(chartArea) { - const me = this; - const gridLines = me.options.gridLines; - const ctx = me.ctx; - const chart = me.chart; - let context = me.getContext(0); - const axisWidth = gridLines.drawBorder ? resolve([gridLines.borderWidth, gridLines.lineWidth, 0], context, 0) : 0; - const items = me._gridLineItems || (me._gridLineItems = me._computeGridLineItems(chartArea)); - let i, ilen; - if (gridLines.display) { - for (i = 0, ilen = items.length; i < ilen; ++i) { - const item = items[i]; - const width = item.width; - const color = item.color; - if (width && color) { - ctx.save(); - ctx.lineWidth = width; - ctx.strokeStyle = color; - if (ctx.setLineDash) { - ctx.setLineDash(item.borderDash); - ctx.lineDashOffset = item.borderDashOffset; - } - ctx.beginPath(); - if (gridLines.drawTicks) { - ctx.moveTo(item.tx1, item.ty1); - ctx.lineTo(item.tx2, item.ty2); - } - if (gridLines.drawOnChartArea) { - ctx.moveTo(item.x1, item.y1); - ctx.lineTo(item.x2, item.y2); - } - ctx.stroke(); - ctx.restore(); - } - } - } - if (axisWidth) { - const firstLineWidth = axisWidth; - context = me.getContext(me._ticksLength - 1); - const lastLineWidth = resolve([gridLines.lineWidth, 1], context, me._ticksLength - 1); - const borderValue = me._borderValue; - let x1, x2, y1, y2; - if (me.isHorizontal()) { - x1 = _alignPixel(chart, me.left, firstLineWidth) - firstLineWidth / 2; - x2 = _alignPixel(chart, me.right, lastLineWidth) + lastLineWidth / 2; - y1 = y2 = borderValue; - } else { - y1 = _alignPixel(chart, me.top, firstLineWidth) - firstLineWidth / 2; - y2 = _alignPixel(chart, me.bottom, lastLineWidth) + lastLineWidth / 2; - x1 = x2 = borderValue; - } - ctx.lineWidth = axisWidth; - ctx.strokeStyle = resolve([gridLines.borderColor, gridLines.color], context, 0); - ctx.beginPath(); - ctx.moveTo(x1, y1); - ctx.lineTo(x2, y2); - ctx.stroke(); - } - } - ; - _proto.drawLabels = function drawLabels(chartArea) { - const me = this; - const optionTicks = me.options.ticks; - if (!optionTicks.display) { - return; - } - const ctx = me.ctx; - const items = me._labelItems || (me._labelItems = me._computeLabelItems(chartArea)); - let i, j, ilen, jlen; - for (i = 0, ilen = items.length; i < ilen; ++i) { - const item = items[i]; - const tickFont = item.font; - const useStroke = tickFont.lineWidth > 0 && tickFont.strokeStyle !== ''; - ctx.save(); - ctx.translate(item.x, item.y); - ctx.rotate(item.rotation); - ctx.font = tickFont.string; - ctx.fillStyle = tickFont.color; - ctx.textAlign = item.textAlign; - ctx.textBaseline = item.textBaseline; - if (useStroke) { - ctx.strokeStyle = tickFont.strokeStyle; - ctx.lineWidth = tickFont.lineWidth; - } - const label = item.label; - let y = item.textOffset; - if (isArray(label)) { - for (j = 0, jlen = label.length; j < jlen; ++j) { - if (useStroke) { - ctx.strokeText('' + label[j], 0, y); - } - ctx.fillText('' + label[j], 0, y); - y += tickFont.lineHeight; - } - } else { - if (useStroke) { - ctx.strokeText(label, 0, y); - } - ctx.fillText(label, 0, y); - } - ctx.restore(); - } - } - ; - _proto.drawTitle = function drawTitle(chartArea) { - const me = this; - const ctx = me.ctx; - const options = me.options; - const scaleLabel = options.scaleLabel; - if (!scaleLabel.display) { - return; - } - const scaleLabelFont = toFont(scaleLabel.font, me.chart.options.font); - const scaleLabelPadding = toPadding(scaleLabel.padding); - const halfLineHeight = scaleLabelFont.lineHeight / 2; - const scaleLabelAlign = scaleLabel.align; - const position = options.position; - const isReverse = me.options.reverse; - let rotation = 0; - let textAlign; - let scaleLabelX, scaleLabelY; - if (me.isHorizontal()) { - switch (scaleLabelAlign) { - case 'start': - scaleLabelX = me.left + (isReverse ? me.width : 0); - textAlign = isReverse ? 'right' : 'left'; - break; - case 'end': - scaleLabelX = me.left + (isReverse ? 0 : me.width); - textAlign = isReverse ? 'left' : 'right'; - break; - default: - scaleLabelX = me.left + me.width / 2; - textAlign = 'center'; - } - scaleLabelY = position === 'top' ? me.top + halfLineHeight + scaleLabelPadding.top : me.bottom - halfLineHeight - scaleLabelPadding.bottom; - } else { - const isLeft = position === 'left'; - scaleLabelX = isLeft ? me.left + halfLineHeight + scaleLabelPadding.top : me.right - halfLineHeight - scaleLabelPadding.top; - switch (scaleLabelAlign) { - case 'start': - scaleLabelY = me.top + (isReverse ? 0 : me.height); - textAlign = isReverse === isLeft ? 'right' : 'left'; - break; - case 'end': - scaleLabelY = me.top + (isReverse ? me.height : 0); - textAlign = isReverse === isLeft ? 'left' : 'right'; - break; - default: - scaleLabelY = me.top + me.height / 2; - textAlign = 'center'; - } - rotation = isLeft ? -HALF_PI : HALF_PI; - } - ctx.save(); - ctx.translate(scaleLabelX, scaleLabelY); - ctx.rotate(rotation); - ctx.textAlign = textAlign; - ctx.textBaseline = 'middle'; - ctx.fillStyle = scaleLabelFont.color; - ctx.font = scaleLabelFont.string; - ctx.fillText(scaleLabel.labelString, 0, 0); - ctx.restore(); - }; - _proto.draw = function draw(chartArea) { - const me = this; - if (!me._isVisible()) { - return; - } - me.drawGrid(chartArea); - me.drawTitle(); - me.drawLabels(chartArea); - } - ; - _proto._layers = function _layers() { - const me = this; - const opts = me.options; - const tz = opts.ticks && opts.ticks.z || 0; - const gz = opts.gridLines && opts.gridLines.z || 0; - if (!me._isVisible() || tz === gz || me.draw !== me._draw) { - return [{ - z: tz, - draw: function draw(chartArea) { - me.draw(chartArea); - } - }]; - } - return [{ - z: gz, - draw: function draw(chartArea) { - me.drawGrid(chartArea); - me.drawTitle(); - } - }, { - z: tz, - draw: function draw(chartArea) { - me.drawLabels(chartArea); - } - }]; - } - ; - _proto.getMatchingVisibleMetas = function getMatchingVisibleMetas(type) { - const me = this; - const metas = me.chart.getSortedVisibleDatasetMetas(); - const axisID = me.axis + 'AxisID'; - const result = []; - let i, ilen; - for (i = 0, ilen = metas.length; i < ilen; ++i) { - const meta = metas[i]; - if (meta[axisID] === me.id && (!type || meta.type === type)) { - result.push(meta); - } - } - return result; - } - ; - _proto._resolveTickFontOptions = function _resolveTickFontOptions(index) { - const me = this; - const chart = me.chart; - const options = me.options.ticks; - const context = me.getContext(index); - return toFont(resolve([options.font], context), chart.options.font); - }; - return Scale; - }(Element$1); - Scale.prototype._draw = Scale.prototype.draw; - - const TypedRegistry = function () { - function TypedRegistry(type, scope) { - this.type = type; - this.scope = scope; - this.items = Object.create(null); - } - const _proto = TypedRegistry.prototype; - _proto.isForType = function isForType(type) { - return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype); - } - ; - _proto.register = function register(item) { - const proto = Object.getPrototypeOf(item); - let parentScope; - if (isIChartComponent(proto)) { - parentScope = this.register(proto); - } - const items = this.items; - const id = item.id; - const baseScope = this.scope; - const scope = baseScope ? baseScope + '.' + id : id; - if (!id) { - throw new Error('class does not have id: ' + item); - } - if (id in items) { - return scope; - } - if (Object.keys(defaults.get(scope)).length) { - throw new Error('Can not register "' + id + '", because "defaults.' + scope + '" would collide with existing defaults'); - } - items[id] = item; - registerDefaults(item, scope, parentScope); - return scope; - } - ; - _proto.get = function get(id) { - return this.items[id]; - } - ; - _proto.unregister = function unregister(item) { - const items = this.items; - const id = item.id; - const scope = this.scope; - if (id in items) { - delete items[id]; - } - if (scope && id in defaults[scope]) { - delete defaults[scope][id]; - } else if (id in defaults) { - delete defaults[id]; - } - }; - return TypedRegistry; - }(); - function registerDefaults(item, scope, parentScope) { - const itemDefaults = parentScope ? _extends({}, defaults.get(parentScope), item.defaults) : item.defaults; - defaults.set(scope, itemDefaults); - if (item.defaultRoutes) { - routeDefaults(scope, item.defaultRoutes); - } - } - function routeDefaults(scope, routes) { - Object.keys(routes).forEach(function (property) { - const parts = routes[property].split('.'); - const targetName = parts.pop(); - const targetScope = parts.join('.'); - defaults.route(scope, property, targetScope, targetName); - }); - } - function isIChartComponent(proto) { - return 'id' in proto && 'defaults' in proto; - } - - const Registry = function () { - function Registry() { - this.controllers = new TypedRegistry(DatasetController, 'controllers'); - this.elements = new TypedRegistry(Element$1, 'elements'); - this.plugins = new TypedRegistry(Object, 'plugins'); - this.scales = new TypedRegistry(Scale, 'scales'); - this._typedRegistries = [this.controllers, this.scales, this.elements]; - } - const _proto = Registry.prototype; - _proto.add = function add() { - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - this._each('register', args); - }; - _proto.remove = function remove() { - for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { - args[_key2] = arguments[_key2]; - } - this._each('unregister', args); - } - ; - _proto.addControllers = function addControllers() { - for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; - } - this._each('register', args, this.controllers); - } - ; - _proto.addElements = function addElements() { - for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { - args[_key4] = arguments[_key4]; - } - this._each('register', args, this.elements); - } - ; - _proto.addPlugins = function addPlugins() { - for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { - args[_key5] = arguments[_key5]; - } - this._each('register', args, this.plugins); - } - ; - _proto.addScales = function addScales() { - for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { - args[_key6] = arguments[_key6]; - } - this._each('register', args, this.scales); - } - ; - _proto.getController = function getController(id) { - return this._get(id, this.controllers, 'controller'); - } - ; - _proto.getElement = function getElement(id) { - return this._get(id, this.elements, 'element'); - } - ; - _proto.getPlugin = function getPlugin(id) { - return this._get(id, this.plugins, 'plugin'); - } - ; - _proto.getScale = function getScale(id) { - return this._get(id, this.scales, 'scale'); - } - ; - _proto.removeControllers = function removeControllers() { - for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) { - args[_key7] = arguments[_key7]; - } - this._each('unregister', args, this.controllers); - } - ; - _proto.removeElements = function removeElements() { - for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) { - args[_key8] = arguments[_key8]; - } - this._each('unregister', args, this.elements); - } - ; - _proto.removePlugins = function removePlugins() { - for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) { - args[_key9] = arguments[_key9]; - } - this._each('unregister', args, this.plugins); - } - ; - _proto.removeScales = function removeScales() { - for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) { - args[_key10] = arguments[_key10]; - } - this._each('unregister', args, this.scales); - } - ; - _proto._each = function _each(method, args, typedRegistry) { - const me = this; - [].concat(args).forEach(function (arg) { - const reg = typedRegistry || me._getRegistryForType(arg); - if (typedRegistry || reg.isForType(arg) || reg === me.plugins && arg.id) { - me._exec(method, reg, arg); + } else if (position === 'right') { + if (mirror) { + x = this.left + padding; + if (crossAlign === 'near') { + textAlign = 'right'; + } else if (crossAlign === 'center') { + textAlign = 'center'; + x -= (widest / 2); } else { - each(arg, function (item) { - const itemReg = typedRegistry || me._getRegistryForType(item); - me._exec(method, itemReg, item); - }); - } - }); - } - ; - _proto._exec = function _exec(method, registry, component) { - const camelMethod = _capitalize(method); - callback(component['before' + camelMethod], [], component); - registry[method](component); - callback(component['after' + camelMethod], [], component); - } - ; - _proto._getRegistryForType = function _getRegistryForType(type) { - for (let i = 0; i < this._typedRegistries.length; i++) { - const reg = this._typedRegistries[i]; - if (reg.isForType(type)) { - return reg; + textAlign = 'left'; + x -= widest; } - } - return this.plugins; - } - ; - _proto._get = function _get(id, typedRegistry, type) { - const item = typedRegistry.get(id); - if (item === undefined) { - throw new Error('"' + id + '" is not a registered ' + type + '.'); - } - return item; - }; - return Registry; - }(); - const registry = new Registry(); - - const PluginService = function () { - function PluginService() {} - const _proto = PluginService.prototype; - _proto.notify = function notify(chart, hook, args) { - const descriptors = this._descriptors(chart); - for (let i = 0; i < descriptors.length; ++i) { - const descriptor = descriptors[i]; - const plugin = descriptor.plugin; - const method = plugin[hook]; - if (typeof method === 'function') { - const params = [chart].concat(args || []); - params.push(descriptor.options); - if (method.apply(plugin, params) === false) { - return false; - } + } else { + x = this.left + tickAndPadding; + if (crossAlign === 'near') { + textAlign = 'left'; + } else if (crossAlign === 'center') { + textAlign = 'center'; + x += widest / 2; + } else { + textAlign = 'right'; + x = this.right; } } - return true; - }; - _proto.invalidate = function invalidate() { - this._cache = undefined; - } - ; - _proto._descriptors = function _descriptors(chart) { - if (this._cache) { - return this._cache; - } - const config = chart && chart.config; - const options = config.options && config.options.plugins || {}; - const plugins = allPlugins(config); - const descriptors = createDescriptors(plugins, options); - this._cache = descriptors; - return descriptors; - }; - return PluginService; - }(); - function allPlugins(config) { - const plugins = []; - const keys = Object.keys(registry.plugins.items); - for (let i = 0; i < keys.length; i++) { - plugins.push(registry.getPlugin(keys[i])); - } - const local = config.plugins || []; - for (let _i = 0; _i < local.length; _i++) { - const plugin = local[_i]; - if (plugins.indexOf(plugin) === -1) { - plugins.push(plugin); - } - } - return plugins; - } - function createDescriptors(plugins, options) { - const result = []; - for (let i = 0; i < plugins.length; i++) { - const plugin = plugins[i]; - const id = plugin.id; - let opts = options[id]; - if (opts === false) { - continue; - } - if (opts === true) { - opts = {}; - } - result.push({ - plugin: plugin, - options: mergeIf({}, [opts, defaults.plugins[id]]) - }); - } - return result; - } - - function getIndexAxis(type, options) { - const typeDefaults = defaults.controllers[type] || {}; - const datasetDefaults = typeDefaults.datasets || {}; - const typeOptions = options[type] || {}; - const datasetOptions = typeOptions.datasets || {}; - return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x'; - } - function getAxisFromDefaultScaleID(id, indexAxis) { - let axis = id; - if (id === '_index_') { - axis = indexAxis; - } else if (id === '_value_') { - axis = indexAxis === 'x' ? 'y' : 'x'; + } else { + textAlign = 'right'; } - return axis; - } - function getDefaultScaleIDFromAxis(axis, indexAxis) { - return axis === indexAxis ? '_index_' : '_value_'; + return {textAlign, x}; } - function axisFromPosition(position) { - if (position === 'top' || position === 'bottom') { - return 'x'; + _computeLabelArea() { + if (this.options.ticks.mirror) { + return; } + const chart = this.chart; + const position = this.options.position; if (position === 'left' || position === 'right') { - return 'y'; - } - } - function determineAxis(id, scaleOptions) { - if (id === 'x' || id === 'y' || id === 'r') { - return id; - } - return scaleOptions.axis || axisFromPosition(scaleOptions.position) || id.charAt(0).toLowerCase(); - } - function mergeScaleConfig(config, options) { - options = options || {}; - const chartDefaults = defaults.controllers[config.type] || { - scales: {} - }; - const configScales = options.scales || {}; - const chartIndexAxis = getIndexAxis(config.type, options); - const firstIDs = Object.create(null); - const scales = Object.create(null); - Object.keys(configScales).forEach(function (id) { - const scaleConf = configScales[id]; - const axis = determineAxis(id, scaleConf); - const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis); - firstIDs[axis] = firstIDs[axis] || id; - scales[id] = mergeIf(Object.create(null), [{ - axis: axis - }, scaleConf, chartDefaults.scales[axis], chartDefaults.scales[defaultId]]); - }); - if (options.scale) { - scales[options.scale.id || 'r'] = mergeIf(Object.create(null), [{ - axis: 'r' - }, options.scale, chartDefaults.scales.r]); - firstIDs.r = firstIDs.r || options.scale.id || 'r'; - } - config.data.datasets.forEach(function (dataset) { - const type = dataset.type || config.type; - const indexAxis = dataset.indexAxis || getIndexAxis(type, options); - const datasetDefaults = defaults.controllers[type] || {}; - const defaultScaleOptions = datasetDefaults.scales || {}; - Object.keys(defaultScaleOptions).forEach(function (defaultID) { - const axis = getAxisFromDefaultScaleID(defaultID, indexAxis); - const id = dataset[axis + 'AxisID'] || firstIDs[axis] || axis; - scales[id] = scales[id] || Object.create(null); - mergeIf(scales[id], [{ - axis: axis - }, configScales[id], defaultScaleOptions[defaultID]]); - }); - }); - Object.keys(scales).forEach(function (key) { - const scale = scales[key]; - mergeIf(scale, [defaults.scales[scale.type], defaults.scale]); - }); - return scales; - } - function mergeConfig() - { - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - return merge(Object.create(null), args, { - merger: function merger(key, target, source, options) { - if (key !== 'scales' && key !== 'scale' && key !== 'controllers') { - _merger(key, target, source, options); - } - } - }); - } - function includeDefaults(config, options) { - const scaleConfig = mergeScaleConfig(config, options); - options = mergeConfig(defaults, defaults.controllers[config.type], options || {}); - options.hover = merge(Object.create(null), [defaults.interaction, defaults.hover, options.interaction, options.hover]); - options.scales = scaleConfig; - options.title = options.title !== false && merge(Object.create(null), [defaults.plugins.title, options.title]); - options.tooltips = options.tooltips !== false && merge(Object.create(null), [defaults.interaction, defaults.plugins.tooltip, options.interaction, options.tooltips]); - return options; - } - function initConfig(config) { - config = config || {}; - const data = config.data = config.data || { - datasets: [], - labels: [] - }; - data.datasets = data.datasets || []; - data.labels = data.labels || []; - config.options = includeDefaults(config, config.options); - return config; - } - const Config = function () { - function Config(config) { - this._config = initConfig(config); - } - const _proto = Config.prototype; - _proto.update = function update(options) { - const config = this._config; - config.options = includeDefaults(config, options); - }; - _createClass(Config, [{ - key: 'type', - get: function get() { - return this._config.type; - } - }, { - key: 'data', - get: function get() { - return this._config.data; - }, - set: function set(data) { - this._config.data = data; - } - }, { - key: 'options', - get: function get() { - return this._config.options; - } - }, { - key: 'plugins', - get: function get() { - return this._config.plugins; - } - }]); - return Config; - }(); - - const version = '3.0.0-beta.6'; - - const KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea']; - function positionIsHorizontal(position, axis) { - return position === 'top' || position === 'bottom' || KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x'; - } - function compare2Level(l1, l2) { - return function (a, b) { - return a[l1] === b[l1] ? a[l2] - b[l2] : a[l1] - b[l1]; - }; - } - function onAnimationsComplete(context) { - const chart = context.chart; - const animationOptions = chart.options.animation; - chart._plugins.notify(chart, 'afterRender'); - callback(animationOptions && animationOptions.onComplete, [context], chart); - } - function onAnimationProgress(context) { - const chart = context.chart; - const animationOptions = chart.options.animation; - callback(animationOptions && animationOptions.onProgress, [context], chart); - } - function isDomSupported() { - return typeof window !== 'undefined' && typeof document !== 'undefined'; - } - function getCanvas(item) { - if (isDomSupported() && typeof item === 'string') { - item = document.getElementById(item); - } else if (item && item.length) { - item = item[0]; + return {top: 0, left: this.left, bottom: chart.height, right: this.right}; + } if (position === 'top' || position === 'bottom') { + return {top: this.top, left: 0, bottom: this.bottom, right: chart.width}; } - if (item && item.canvas) { - item = item.canvas; - } - return item; } - const Chart = function () { - function Chart(item, config) { - const me = this; - this.config = config = new Config(config); - const initialCanvas = getCanvas(item); - const existingChart = Chart.getChart(initialCanvas); - if (existingChart) { - throw new Error('Canvas is already in use. Chart with ID \'' + existingChart.id + '\'' + ' must be destroyed before the canvas can be reused.'); - } - this.platform = me._initializePlatform(initialCanvas, config); - const context = me.platform.acquireContext(initialCanvas, config); - const canvas = context && context.canvas; - const height = canvas && canvas.height; - const width = canvas && canvas.width; - this.id = uid(); - this.ctx = context; - this.canvas = canvas; - this.width = width; - this.height = height; - this.aspectRatio = height ? width / height : null; - this.options = config.options; - this._layers = []; - this._metasets = []; - this.boxes = []; - this.currentDevicePixelRatio = undefined; - this.chartArea = undefined; - this._active = []; - this._lastEvent = undefined; - this._listeners = {}; - this._sortedMetasets = []; - this.scales = {}; - this.scale = undefined; - this._plugins = new PluginService(); - this.$proxies = {}; - this._hiddenIndices = {}; - this.attached = false; - this._animationsDisabled = undefined; - this.$context = undefined; - Chart.instances[me.id] = me; - if (!context || !canvas) { - console.error('Failed to create chart: can\'t acquire context from the given item'); - return; - } - animator.listen(me, 'complete', onAnimationsComplete); - animator.listen(me, 'progress', onAnimationProgress); - me._initialize(); - if (me.attached) { - me.update(); - } - } - const _proto = Chart.prototype; - _proto._initialize = function _initialize() { - const me = this; - me._plugins.notify(me, 'beforeInit'); - if (me.options.responsive) { - me.resize(); - } else { - retinaScale(me, me.options.devicePixelRatio); - } - me.bindEvents(); - me._plugins.notify(me, 'afterInit'); - return me; - } - ; - _proto._initializePlatform = function _initializePlatform(canvas, config) { - if (config.platform) { - return new config.platform(); - } else if (!isDomSupported() || typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas) { - return new BasicPlatform(); - } - return new DomPlatform(); - }; - _proto.clear = function clear$1() { - clear(this); - return this; - }; - _proto.stop = function stop() { - animator.stop(this); - return this; - }; - _proto.resize = function resize(width, height) { - if (!animator.running(this)) { - this._resize(width, height); - } else { - this._resizeBeforeDraw = { - width: width, - height: height - }; - } - }; - _proto._resize = function _resize(width, height) { - const me = this; - const options = me.options; - const canvas = me.canvas; - const aspectRatio = options.maintainAspectRatio && me.aspectRatio; - const newSize = me.platform.getMaximumSize(canvas, width, height, aspectRatio); - const oldRatio = me.currentDevicePixelRatio; - const newRatio = options.devicePixelRatio || me.platform.getDevicePixelRatio(); - if (me.width === newSize.width && me.height === newSize.height && oldRatio === newRatio) { - return; - } - canvas.width = me.width = newSize.width; - canvas.height = me.height = newSize.height; - if (canvas.style) { - canvas.style.width = newSize.width + 'px'; - canvas.style.height = newSize.height + 'px'; - } - retinaScale(me, newRatio); - me._plugins.notify(me, 'resize', [newSize]); - callback(options.onResize, [newSize], me); - if (me.attached) { - me.update('resize'); - } - }; - _proto.ensureScalesHaveIDs = function ensureScalesHaveIDs() { - const options = this.options; - const scalesOptions = options.scales || {}; - const scaleOptions = options.scale; - each(scalesOptions, function (axisOptions, axisID) { - axisOptions.id = axisID; - }); - if (scaleOptions) { - scaleOptions.id = scaleOptions.id || 'scale'; - } - } - ; - _proto.buildOrUpdateScales = function buildOrUpdateScales() { - const me = this; - const options = me.options; - const scaleOpts = options.scales; - const scales = me.scales || {}; - const updated = Object.keys(scales).reduce(function (obj, id) { - obj[id] = false; - return obj; - }, {}); - let items = []; - if (scaleOpts) { - items = items.concat(Object.keys(scaleOpts).map(function (id) { - const scaleOptions = scaleOpts[id]; - const axis = determineAxis(id, scaleOptions); - const isRadial = axis === 'r'; - const isHorizontal = axis === 'x'; - return { - options: scaleOptions, - dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left', - dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear' - }; - })); - } - each(items, function (item) { - const scaleOptions = item.options; - const id = scaleOptions.id; - const axis = determineAxis(id, scaleOptions); - const scaleType = valueOrDefault(scaleOptions.type, item.dtype); - if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) { - scaleOptions.position = item.dposition; - } - updated[id] = true; - let scale = null; - if (id in scales && scales[id].type === scaleType) { - scale = scales[id]; - } else { - const scaleClass = registry.getScale(scaleType); - scale = new scaleClass({ - id: id, - type: scaleType, - ctx: me.ctx, - chart: me - }); - scales[scale.id] = scale; - } - scale.init(scaleOptions, options); - if (item.isDefault) { - me.scale = scale; - } - }); - each(updated, function (hasUpdated, id) { - if (!hasUpdated) { - delete scales[id]; - } - }); - me.scales = scales; - each(scales, function (scale) { - scale.fullWidth = scale.options.fullWidth; - scale.position = scale.options.position; - scale.weight = scale.options.weight; - layouts.addBox(me, scale); - }); - } - ; - _proto._updateMetasetIndex = function _updateMetasetIndex(meta, index) { - const metasets = this._metasets; - const oldIndex = meta.index; - if (oldIndex !== index) { - metasets[oldIndex] = metasets[index]; - metasets[index] = meta; - meta.index = index; - } - } - ; - _proto._updateMetasets = function _updateMetasets() { - const me = this; - const metasets = me._metasets; - const numData = me.data.datasets.length; - const numMeta = metasets.length; - if (numMeta > numData) { - for (let i = numData; i < numMeta; ++i) { - me._destroyDatasetMeta(i); - } - metasets.splice(numData, numMeta - numData); - } - me._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index')); - } - ; - _proto._removeUnreferencedMetasets = function _removeUnreferencedMetasets() { - const me = this; - const datasets = me.data.datasets; - me._metasets.forEach(function (meta, index) { - if (datasets.filter(function (x) { - return x === meta._dataset; - }).length === 0) { - me._destroyDatasetMeta(index); - } - }); - }; - _proto.buildOrUpdateControllers = function buildOrUpdateControllers() { - const me = this; - const newControllers = []; - const datasets = me.data.datasets; - let i, ilen; - me._removeUnreferencedMetasets(); - for (i = 0, ilen = datasets.length; i < ilen; i++) { - const dataset = datasets[i]; - let meta = me.getDatasetMeta(i); - const type = dataset.type || me.config.type; - if (meta.type && meta.type !== type) { - me._destroyDatasetMeta(i); - meta = me.getDatasetMeta(i); - } - meta.type = type; - meta.indexAxis = dataset.indexAxis || getIndexAxis(type, me.options); - meta.order = dataset.order || 0; - me._updateMetasetIndex(meta, i); - meta.label = '' + dataset.label; - meta.visible = me.isDatasetVisible(i); - if (meta.controller) { - meta.controller.updateIndex(i); - meta.controller.linkScales(); - } else { - const controllerDefaults = defaults.controllers[type]; - const ControllerClass = registry.getController(type); - _extends(ControllerClass.prototype, { - dataElementType: registry.getElement(controllerDefaults.dataElementType), - datasetElementType: controllerDefaults.datasetElementType && registry.getElement(controllerDefaults.datasetElementType), - dataElementOptions: controllerDefaults.dataElementOptions, - datasetElementOptions: controllerDefaults.datasetElementOptions - }); - meta.controller = new ControllerClass(me, i); - newControllers.push(meta.controller); - } - } - me._updateMetasets(); - return newControllers; - } - ; - _proto._resetElements = function _resetElements() { - const me = this; - each(me.data.datasets, function (dataset, datasetIndex) { - me.getDatasetMeta(datasetIndex).controller.reset(); - }, me); - } - ; - _proto.reset = function reset() { - this._resetElements(); - this._plugins.notify(this, 'reset'); - }; - _proto.update = function update(mode) { - const me = this; - const args = { - mode: mode - }; - let i, ilen; - each(me.scales, function (scale) { - layouts.removeBox(me, scale); - }); - me.config.update(me.options); - me.options = me.config.options; - me._animationsDisabled = !me.options.animation; - me.ensureScalesHaveIDs(); - me.buildOrUpdateScales(); - me._plugins.invalidate(); - if (me._plugins.notify(me, 'beforeUpdate', [args]) === false) { - return; - } - const newControllers = me.buildOrUpdateControllers(); - for (i = 0, ilen = me.data.datasets.length; i < ilen; i++) { - me.getDatasetMeta(i).controller.buildOrUpdateElements(); - } - me._updateLayout(); - each(newControllers, function (controller) { - controller.reset(); - }); - me._updateDatasets(mode); - me._plugins.notify(me, 'afterUpdate', [args]); - me._layers.sort(compare2Level('z', '_idx')); - if (me._lastEvent) { - me._eventHandler(me._lastEvent, true); - } - me.render(); - } - ; - _proto._updateLayout = function _updateLayout() { - const me = this; - if (me._plugins.notify(me, 'beforeLayout') === false) { - return; - } - layouts.update(me, me.width, me.height); - me._layers = []; - each(me.boxes, function (box) { - let _me$_layers; - if (box.configure) { - box.configure(); - } - (_me$_layers = me._layers).push.apply(_me$_layers, box._layers()); - }, me); - me._layers.forEach(function (item, index) { - item._idx = index; - }); - me._plugins.notify(me, 'afterLayout'); - } - ; - _proto._updateDatasets = function _updateDatasets(mode) { - const me = this; - const isFunction = typeof mode === 'function'; - const args = { - mode: mode - }; - if (me._plugins.notify(me, 'beforeDatasetsUpdate', [args]) === false) { - return; - } - for (let i = 0, ilen = me.data.datasets.length; i < ilen; ++i) { - me._updateDataset(i, isFunction ? mode({ - datasetIndex: i - }) : mode); - } - me._plugins.notify(me, 'afterDatasetsUpdate', [args]); - } - ; - _proto._updateDataset = function _updateDataset(index, mode) { - const me = this; - const meta = me.getDatasetMeta(index); - const args = { - meta: meta, - index: index, - mode: mode - }; - if (me._plugins.notify(me, 'beforeDatasetUpdate', [args]) === false) { - return; - } - meta.controller._update(mode); - me._plugins.notify(me, 'afterDatasetUpdate', [args]); - }; - _proto.render = function render() { - const me = this; - if (me._plugins.notify(me, 'beforeRender') === false) { - return; - } - if (animator.has(me)) { - if (me.attached && !animator.running(me)) { - animator.start(me); - } - } else { - me.draw(); - onAnimationsComplete({ - chart: me - }); - } - }; - _proto.draw = function draw() { - const me = this; - let i; - if (me._resizeBeforeDraw) { - const _me$_resizeBeforeDraw = me._resizeBeforeDraw, - width = _me$_resizeBeforeDraw.width, - height = _me$_resizeBeforeDraw.height; - me._resize(width, height); - me._resizeBeforeDraw = null; - } - me.clear(); - if (me.width <= 0 || me.height <= 0) { - return; - } - if (me._plugins.notify(me, 'beforeDraw') === false) { - return; - } - const layers = me._layers; - for (i = 0; i < layers.length && layers[i].z <= 0; ++i) { - layers[i].draw(me.chartArea); - } - me._drawDatasets(); - for (; i < layers.length; ++i) { - layers[i].draw(me.chartArea); - } - me._plugins.notify(me, 'afterDraw'); - } - ; - _proto._getSortedDatasetMetas = function _getSortedDatasetMetas(filterVisible) { - const me = this; - const metasets = me._sortedMetasets; - const result = []; - let i, ilen; - for (i = 0, ilen = metasets.length; i < ilen; ++i) { - const meta = metasets[i]; - if (!filterVisible || meta.visible) { - result.push(meta); - } - } - return result; - } - ; - _proto.getSortedVisibleDatasetMetas = function getSortedVisibleDatasetMetas() { - return this._getSortedDatasetMetas(true); - } - ; - _proto._drawDatasets = function _drawDatasets() { - const me = this; - if (me._plugins.notify(me, 'beforeDatasetsDraw') === false) { - return; - } - const metasets = me.getSortedVisibleDatasetMetas(); - for (let i = metasets.length - 1; i >= 0; --i) { - me._drawDataset(metasets[i]); - } - me._plugins.notify(me, 'afterDatasetsDraw'); - } - ; - _proto._drawDataset = function _drawDataset(meta) { - const me = this; - const ctx = me.ctx; - const clip = meta._clip; - const area = me.chartArea; - const args = { - meta: meta, - index: meta.index - }; - if (me._plugins.notify(me, 'beforeDatasetDraw', [args]) === false) { - return; - } - clipArea(ctx, { - left: clip.left === false ? 0 : area.left - clip.left, - right: clip.right === false ? me.width : area.right + clip.right, - top: clip.top === false ? 0 : area.top - clip.top, - bottom: clip.bottom === false ? me.height : area.bottom + clip.bottom - }); - meta.controller.draw(); - unclipArea(ctx); - me._plugins.notify(me, 'afterDatasetDraw', [args]); - }; - _proto.getElementsAtEventForMode = function getElementsAtEventForMode(e, mode, options, useFinalPosition) { - const method = Interaction.modes[mode]; - if (typeof method === 'function') { - return method(this, e, options, useFinalPosition); - } - return []; - }; - _proto.getDatasetMeta = function getDatasetMeta(datasetIndex) { - const me = this; - const dataset = me.data.datasets[datasetIndex]; - const metasets = me._metasets; - let meta = metasets.filter(function (x) { - return x && x._dataset === dataset; - }).pop(); - if (!meta) { - meta = metasets[datasetIndex] = { - type: null, - data: [], - dataset: null, - controller: null, - hidden: null, - xAxisID: null, - yAxisID: null, - order: dataset.order || 0, - index: datasetIndex, - _dataset: dataset, - _parsed: [], - _sorted: false - }; - } - return meta; - }; - _proto.getContext = function getContext() { - return this.$context || (this.$context = Object.create(null, { - chart: { - value: this - }, - type: { - value: 'chart' - } - })); - }; - _proto.getVisibleDatasetCount = function getVisibleDatasetCount() { - return this.getSortedVisibleDatasetMetas().length; - }; - _proto.isDatasetVisible = function isDatasetVisible(datasetIndex) { - const dataset = this.data.datasets[datasetIndex]; - if (!dataset) { - return false; - } - const meta = this.getDatasetMeta(datasetIndex); - return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden; - }; - _proto.setDatasetVisibility = function setDatasetVisibility(datasetIndex, visible) { - const meta = this.getDatasetMeta(datasetIndex); - meta.hidden = !visible; - }; - _proto.toggleDataVisibility = function toggleDataVisibility(index) { - this._hiddenIndices[index] = !this._hiddenIndices[index]; - }; - _proto.getDataVisibility = function getDataVisibility(index) { - return !this._hiddenIndices[index]; - } - ; - _proto._updateDatasetVisibility = function _updateDatasetVisibility(datasetIndex, visible) { - const me = this; - const mode = visible ? 'show' : 'hide'; - const meta = me.getDatasetMeta(datasetIndex); - const anims = meta.controller._resolveAnimations(undefined, mode); - me.setDatasetVisibility(datasetIndex, visible); - anims.update(meta, { - visible: visible - }); - me.update(function (ctx) { - return ctx.datasetIndex === datasetIndex ? mode : undefined; - }); - }; - _proto.hide = function hide(datasetIndex) { - this._updateDatasetVisibility(datasetIndex, false); - }; - _proto.show = function show(datasetIndex) { - this._updateDatasetVisibility(datasetIndex, true); - } - ; - _proto._destroyDatasetMeta = function _destroyDatasetMeta(datasetIndex) { - const me = this; - const meta = me._metasets && me._metasets[datasetIndex]; - if (meta) { - meta.controller._destroy(); - delete me._metasets[datasetIndex]; - } - }; - _proto.destroy = function destroy() { - const me = this; - const canvas = me.canvas; - let i, ilen; - me.stop(); - animator.remove(me); - for (i = 0, ilen = me.data.datasets.length; i < ilen; ++i) { - me._destroyDatasetMeta(i); - } - if (canvas) { - me.unbindEvents(); - clear(me); - me.platform.releaseContext(me.ctx); - me.canvas = null; - me.ctx = null; - } - me._plugins.notify(me, 'destroy'); - delete Chart.instances[me.id]; - }; - _proto.toBase64Image = function toBase64Image() { - let _this$canvas; - return (_this$canvas = this.canvas).toDataURL.apply(_this$canvas, arguments); - } - ; - _proto.bindEvents = function bindEvents() { - const me = this; - const listeners = me._listeners; - const platform = me.platform; - const _add = function _add(type, listener) { - platform.addEventListener(me, type, listener); - listeners[type] = listener; - }; - const _remove = function _remove(type, listener) { - if (listeners[type]) { - platform.removeEventListener(me, type, listener); - delete listeners[type]; - } - }; - let listener = function listener(e, x, y) { - e.offsetX = x; - e.offsetY = y; - me._eventHandler(e); - }; - each(me.options.events, function (type) { - return _add(type, listener); - }); - if (me.options.responsive) { - listener = function listener(width, height) { - if (me.canvas) { - me.resize(width, height); - } - }; - let detached; - const attached = function attached() { - _remove('attach', attached); - me.attached = true; - me.resize(); - _add('resize', listener); - _add('detach', detached); - }; - detached = function detached() { - me.attached = false; - _remove('resize', listener); - _add('attach', attached); - }; - if (platform.isAttached(me.canvas)) { - attached(); - } else { - detached(); - } - } else { - me.attached = true; - } + drawBackground() { + const {ctx, options: {backgroundColor}, left, top, width, height} = this; + if (backgroundColor) { + ctx.save(); + ctx.fillStyle = backgroundColor; + ctx.fillRect(left, top, width, height); + ctx.restore(); } - ; - _proto.unbindEvents = function unbindEvents() { - const me = this; - const listeners = me._listeners; - if (!listeners) { + } + getLineWidthForValue(value) { + const grid = this.options.grid; + if (!this._isVisible() || !grid.display) { + return 0; + } + const ticks = this.ticks; + const index = ticks.findIndex(t => t.value === value); + if (index >= 0) { + const opts = grid.setContext(this.getContext(index)); + return opts.lineWidth; + } + return 0; + } + drawGrid(chartArea) { + const grid = this.options.grid; + const ctx = this.ctx; + const items = this._gridLineItems || (this._gridLineItems = this._computeGridLineItems(chartArea)); + let i, ilen; + const drawLine = (p1, p2, style) => { + if (!style.width || !style.color) { return; } - delete me._listeners; - each(listeners, function (listener, type) { - me.platform.removeEventListener(me, type, listener); - }); + ctx.save(); + ctx.lineWidth = style.width; + ctx.strokeStyle = style.color; + ctx.setLineDash(style.borderDash || []); + ctx.lineDashOffset = style.borderDashOffset; + ctx.beginPath(); + ctx.moveTo(p1.x, p1.y); + ctx.lineTo(p2.x, p2.y); + ctx.stroke(); + ctx.restore(); }; - _proto.updateHoverStyle = function updateHoverStyle(items, mode, enabled) { - const prefix = enabled ? 'set' : 'remove'; - let meta, item, i, ilen; - if (mode === 'dataset') { - meta = this.getDatasetMeta(items[0].datasetIndex); - meta.controller['_' + prefix + 'DatasetHoverStyle'](); - } + if (grid.display) { for (i = 0, ilen = items.length; i < ilen; ++i) { - item = items[i]; - if (item) { - this.getDatasetMeta(item.datasetIndex).controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index); + const item = items[i]; + if (grid.drawOnChartArea) { + drawLine( + {x: item.x1, y: item.y1}, + {x: item.x2, y: item.y2}, + item + ); + } + if (grid.drawTicks) { + drawLine( + {x: item.tx1, y: item.ty1}, + {x: item.tx2, y: item.ty2}, + { + color: item.tickColor, + width: item.tickWidth, + borderDash: item.tickBorderDash, + borderDashOffset: item.tickBorderDashOffset + } + ); } } } - ; - _proto.getActiveElements = function getActiveElements() { - return this._active || []; - } - ; - _proto.setActiveElements = function setActiveElements(activeElements) { - const me = this; - const lastActive = me._active || []; - const active = activeElements.map(function (_ref) { - const datasetIndex = _ref.datasetIndex, - index = _ref.index; - const meta = me.getDatasetMeta(datasetIndex); - if (!meta) { - throw new Error('No dataset found at index ' + datasetIndex); - } - return { - datasetIndex: datasetIndex, - element: meta.data[index], - index: index - }; - }); - const changed = !_elementsEqual(active, lastActive); - if (changed) { - me._active = active; - me._updateHoverStyles(active, lastActive); - } + } + drawBorder() { + const {chart, ctx, options: {grid}} = this; + const borderOpts = grid.setContext(this.getContext()); + const axisWidth = grid.drawBorder ? borderOpts.borderWidth : 0; + if (!axisWidth) { + return; } - ; - _proto._updateHoverStyles = function _updateHoverStyles(active, lastActive) { - const me = this; - const options = me.options || {}; - const hoverOptions = options.hover; - if (lastActive.length) { - me.updateHoverStyle(lastActive, hoverOptions.mode, false); - } - if (active.length && hoverOptions.mode) { - me.updateHoverStyle(active, hoverOptions.mode, true); - } + const lastLineWidth = grid.setContext(this.getContext(0)).lineWidth; + const borderValue = this._borderValue; + let x1, x2, y1, y2; + if (this.isHorizontal()) { + x1 = _alignPixel(chart, this.left, axisWidth) - axisWidth / 2; + x2 = _alignPixel(chart, this.right, lastLineWidth) + lastLineWidth / 2; + y1 = y2 = borderValue; + } else { + y1 = _alignPixel(chart, this.top, axisWidth) - axisWidth / 2; + y2 = _alignPixel(chart, this.bottom, lastLineWidth) + lastLineWidth / 2; + x1 = x2 = borderValue; } - ; - _proto._eventHandler = function _eventHandler(e, replay) { - const me = this; - if (me._plugins.notify(me, 'beforeEvent', [e, replay]) === false) { - return; - } - me._handleEvent(e, replay); - me._plugins.notify(me, 'afterEvent', [e, replay]); - me.render(); - return me; - } - ; - _proto._handleEvent = function _handleEvent(e, replay) { - const me = this; - const lastActive = me._active || []; - const options = me.options; - const hoverOptions = options.hover; - const useFinalPosition = replay; - let active = []; - let changed = false; - if (e.type === 'mouseout') { - me._lastEvent = null; - } else { - active = me.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition); - me._lastEvent = e.type === 'click' ? me._lastEvent : e; - } - callback(options.onHover || options.hover.onHover, [e, active, me], me); - if (e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu') { - if (_isPointInArea(e, me.chartArea)) { - callback(options.onClick, [e, active, me], me); - } + ctx.save(); + ctx.lineWidth = borderOpts.borderWidth; + ctx.strokeStyle = borderOpts.borderColor; + ctx.beginPath(); + ctx.moveTo(x1, y1); + ctx.lineTo(x2, y2); + ctx.stroke(); + ctx.restore(); + } + drawLabels(chartArea) { + const optionTicks = this.options.ticks; + if (!optionTicks.display) { + return; + } + const ctx = this.ctx; + const area = this._computeLabelArea(); + if (area) { + clipArea(ctx, area); + } + const items = this._labelItems || (this._labelItems = this._computeLabelItems(chartArea)); + let i, ilen; + for (i = 0, ilen = items.length; i < ilen; ++i) { + const item = items[i]; + const tickFont = item.font; + const label = item.label; + if (item.backdrop) { + ctx.fillStyle = item.backdrop.color; + ctx.fillRect(item.backdrop.left, item.backdrop.top, item.backdrop.width, item.backdrop.height); } - changed = !_elementsEqual(active, lastActive); - if (changed || replay) { - me._active = active; - me._updateHoverStyles(active, lastActive); + let y = item.textOffset; + renderText(ctx, label, 0, y, tickFont, item); + } + if (area) { + unclipArea(ctx); + } + } + drawTitle() { + const {ctx, options: {position, title, reverse}} = this; + if (!title.display) { + return; + } + const font = toFont(title.font); + const padding = toPadding(title.padding); + const align = title.align; + let offset = font.lineHeight / 2; + if (position === 'bottom' || position === 'center' || isObject(position)) { + offset += padding.bottom; + if (isArray(title.text)) { + offset += font.lineHeight * (title.text.length - 1); } - return changed; - }; - _createClass(Chart, [{ - key: 'data', - get: function get() { - return this.config.data; - }, - set: function set(data) { - this.config.data = data; - } - }]); - return Chart; - }(); - Chart.defaults = defaults; - Chart.instances = {}; - Chart.registry = registry; - Chart.version = version; - Chart.getChart = function (key) { - const canvas = getCanvas(key); - return Object.values(Chart.instances).filter(function (c) { - return c.canvas === canvas; - }).pop(); - }; - const invalidatePlugins = function invalidatePlugins() { - return each(Chart.instances, function (chart) { - return chart._plugins.invalidate(); + } else { + offset += padding.top; + } + const {titleX, titleY, maxWidth, rotation} = titleArgs(this, offset, position, align); + renderText(ctx, title.text, 0, 0, font, { + color: title.color, + maxWidth, + rotation, + textAlign: titleAlign(align, position, reverse), + textBaseline: 'middle', + translation: [titleX, titleY], }); - }; - Chart.register = function () { - registry.add.apply(registry, arguments); - invalidatePlugins(); - }; - Chart.unregister = function () { - registry.remove.apply(registry, arguments); - invalidatePlugins(); - }; - - const EPSILON = Number.EPSILON || 1e-14; - function splineCurve(firstPoint, middlePoint, afterPoint, t) { - const previous = firstPoint.skip ? middlePoint : firstPoint; - const current = middlePoint; - const next = afterPoint.skip ? middlePoint : afterPoint; - const d01 = Math.sqrt(Math.pow(current.x - previous.x, 2) + Math.pow(current.y - previous.y, 2)); - const d12 = Math.sqrt(Math.pow(next.x - current.x, 2) + Math.pow(next.y - current.y, 2)); - let s01 = d01 / (d01 + d12); - let s12 = d12 / (d01 + d12); - s01 = isNaN(s01) ? 0 : s01; - s12 = isNaN(s12) ? 0 : s12; - const fa = t * s01; - const fb = t * s12; - return { - previous: { - x: current.x - fa * (next.x - previous.x), - y: current.y - fa * (next.y - previous.y) - }, - next: { - x: current.x + fb * (next.x - previous.x), - y: current.y + fb * (next.y - previous.y) - } - }; } - function splineCurveMonotone(points) { - const pointsWithTangents = (points || []).map(function (point) { - return { - model: point, - deltaK: 0, - mK: 0 - }; - }); - const pointsLen = pointsWithTangents.length; - let i, pointBefore, pointCurrent, pointAfter; - for (i = 0; i < pointsLen; ++i) { - pointCurrent = pointsWithTangents[i]; - if (pointCurrent.model.skip) { - continue; - } - pointBefore = i > 0 ? pointsWithTangents[i - 1] : null; - pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null; - if (pointAfter && !pointAfter.model.skip) { - const slopeDeltaX = pointAfter.model.x - pointCurrent.model.x; - pointCurrent.deltaK = slopeDeltaX !== 0 ? (pointAfter.model.y - pointCurrent.model.y) / slopeDeltaX : 0; - } - if (!pointBefore || pointBefore.model.skip) { - pointCurrent.mK = pointCurrent.deltaK; - } else if (!pointAfter || pointAfter.model.skip) { - pointCurrent.mK = pointBefore.deltaK; - } else if (sign(pointBefore.deltaK) !== sign(pointCurrent.deltaK)) { - pointCurrent.mK = 0; - } else { - pointCurrent.mK = (pointBefore.deltaK + pointCurrent.deltaK) / 2; - } + draw(chartArea) { + if (!this._isVisible()) { + return; } - let alphaK, betaK, tauK, squaredMagnitude; - for (i = 0; i < pointsLen - 1; ++i) { - pointCurrent = pointsWithTangents[i]; - pointAfter = pointsWithTangents[i + 1]; - if (pointCurrent.model.skip || pointAfter.model.skip) { - continue; - } - if (almostEquals(pointCurrent.deltaK, 0, EPSILON)) { - pointCurrent.mK = pointAfter.mK = 0; - continue; - } - alphaK = pointCurrent.mK / pointCurrent.deltaK; - betaK = pointAfter.mK / pointCurrent.deltaK; - squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2); - if (squaredMagnitude <= 9) { - continue; - } - tauK = 3 / Math.sqrt(squaredMagnitude); - pointCurrent.mK = alphaK * tauK * pointCurrent.deltaK; - pointAfter.mK = betaK * tauK * pointCurrent.deltaK; + this.drawBackground(); + this.drawGrid(chartArea); + this.drawBorder(); + this.drawTitle(); + this.drawLabels(chartArea); + } + _layers() { + const opts = this.options; + const tz = opts.ticks && opts.ticks.z || 0; + const gz = valueOrDefault(opts.grid && opts.grid.z, -1); + if (!this._isVisible() || this.draw !== Scale.prototype.draw) { + return [{ + z: tz, + draw: (chartArea) => { + this.draw(chartArea); + } + }]; } - let deltaX; - for (i = 0; i < pointsLen; ++i) { - pointCurrent = pointsWithTangents[i]; - if (pointCurrent.model.skip) { - continue; + return [{ + z: gz, + draw: (chartArea) => { + this.drawBackground(); + this.drawGrid(chartArea); + this.drawTitle(); + } + }, { + z: gz + 1, + draw: () => { + this.drawBorder(); } - pointBefore = i > 0 ? pointsWithTangents[i - 1] : null; - pointAfter = i < pointsLen - 1 ? pointsWithTangents[i + 1] : null; - if (pointBefore && !pointBefore.model.skip) { - deltaX = (pointCurrent.model.x - pointBefore.model.x) / 3; - pointCurrent.model.controlPointPreviousX = pointCurrent.model.x - deltaX; - pointCurrent.model.controlPointPreviousY = pointCurrent.model.y - deltaX * pointCurrent.mK; + }, { + z: tz, + draw: (chartArea) => { + this.drawLabels(chartArea); } - if (pointAfter && !pointAfter.model.skip) { - deltaX = (pointAfter.model.x - pointCurrent.model.x) / 3; - pointCurrent.model.controlPointNextX = pointCurrent.model.x + deltaX; - pointCurrent.model.controlPointNextY = pointCurrent.model.y + deltaX * pointCurrent.mK; + }]; + } + getMatchingVisibleMetas(type) { + const metas = this.chart.getSortedVisibleDatasetMetas(); + const axisID = this.axis + 'AxisID'; + const result = []; + let i, ilen; + for (i = 0, ilen = metas.length; i < ilen; ++i) { + const meta = metas[i]; + if (meta[axisID] === this.id && (!type || meta.type === type)) { + result.push(meta); } } + return result; } - function capControlPoint(pt, min, max) { - return Math.max(Math.min(pt, max), min); + _resolveTickFontOptions(index) { + const opts = this.options.ticks.setContext(this.getContext(index)); + return toFont(opts.font); } - function capBezierPoints(points, area) { - let i, ilen, point; - for (i = 0, ilen = points.length; i < ilen; ++i) { - point = points[i]; - if (!_isPointInArea(point, area)) { - continue; - } - if (i > 0 && _isPointInArea(points[i - 1], area)) { - point.controlPointPreviousX = capControlPoint(point.controlPointPreviousX, area.left, area.right); - point.controlPointPreviousY = capControlPoint(point.controlPointPreviousY, area.top, area.bottom); + _maxDigits() { + const fontSize = this._resolveTickFontOptions(0).lineHeight; + return (this.isHorizontal() ? this.width : this.height) / fontSize; + } +} + +class TypedRegistry { + constructor(type, scope, override) { + this.type = type; + this.scope = scope; + this.override = override; + this.items = Object.create(null); + } + isForType(type) { + return Object.prototype.isPrototypeOf.call(this.type.prototype, type.prototype); + } + register(item) { + const proto = Object.getPrototypeOf(item); + let parentScope; + if (isIChartComponent(proto)) { + parentScope = this.register(proto); + } + const items = this.items; + const id = item.id; + const scope = this.scope + '.' + id; + if (!id) { + throw new Error('class does not have id: ' + item); + } + if (id in items) { + return scope; + } + items[id] = item; + registerDefaults(item, scope, parentScope); + if (this.override) { + defaults.override(item.id, item.overrides); + } + return scope; + } + get(id) { + return this.items[id]; + } + unregister(item) { + const items = this.items; + const id = item.id; + const scope = this.scope; + if (id in items) { + delete items[id]; + } + if (scope && id in defaults[scope]) { + delete defaults[scope][id]; + if (this.override) { + delete overrides[id]; + } + } + } +} +function registerDefaults(item, scope, parentScope) { + const itemDefaults = merge(Object.create(null), [ + parentScope ? defaults.get(parentScope) : {}, + defaults.get(scope), + item.defaults + ]); + defaults.set(scope, itemDefaults); + if (item.defaultRoutes) { + routeDefaults(scope, item.defaultRoutes); + } + if (item.descriptors) { + defaults.describe(scope, item.descriptors); + } +} +function routeDefaults(scope, routes) { + Object.keys(routes).forEach(property => { + const propertyParts = property.split('.'); + const sourceName = propertyParts.pop(); + const sourceScope = [scope].concat(propertyParts).join('.'); + const parts = routes[property].split('.'); + const targetName = parts.pop(); + const targetScope = parts.join('.'); + defaults.route(sourceScope, sourceName, targetScope, targetName); + }); +} +function isIChartComponent(proto) { + return 'id' in proto && 'defaults' in proto; +} + +class Registry { + constructor() { + this.controllers = new TypedRegistry(DatasetController, 'datasets', true); + this.elements = new TypedRegistry(Element, 'elements'); + this.plugins = new TypedRegistry(Object, 'plugins'); + this.scales = new TypedRegistry(Scale, 'scales'); + this._typedRegistries = [this.controllers, this.scales, this.elements]; + } + add(...args) { + this._each('register', args); + } + remove(...args) { + this._each('unregister', args); + } + addControllers(...args) { + this._each('register', args, this.controllers); + } + addElements(...args) { + this._each('register', args, this.elements); + } + addPlugins(...args) { + this._each('register', args, this.plugins); + } + addScales(...args) { + this._each('register', args, this.scales); + } + getController(id) { + return this._get(id, this.controllers, 'controller'); + } + getElement(id) { + return this._get(id, this.elements, 'element'); + } + getPlugin(id) { + return this._get(id, this.plugins, 'plugin'); + } + getScale(id) { + return this._get(id, this.scales, 'scale'); + } + removeControllers(...args) { + this._each('unregister', args, this.controllers); + } + removeElements(...args) { + this._each('unregister', args, this.elements); + } + removePlugins(...args) { + this._each('unregister', args, this.plugins); + } + removeScales(...args) { + this._each('unregister', args, this.scales); + } + _each(method, args, typedRegistry) { + [...args].forEach(arg => { + const reg = typedRegistry || this._getRegistryForType(arg); + if (typedRegistry || reg.isForType(arg) || (reg === this.plugins && arg.id)) { + this._exec(method, reg, arg); + } else { + each(arg, item => { + const itemReg = typedRegistry || this._getRegistryForType(item); + this._exec(method, itemReg, item); + }); } - if (i < points.length - 1 && _isPointInArea(points[i + 1], area)) { - point.controlPointNextX = capControlPoint(point.controlPointNextX, area.left, area.right); - point.controlPointNextY = capControlPoint(point.controlPointNextY, area.top, area.bottom); + }); + } + _exec(method, registry, component) { + const camelMethod = _capitalize(method); + callback(component['before' + camelMethod], [], component); + registry[method](component); + callback(component['after' + camelMethod], [], component); + } + _getRegistryForType(type) { + for (let i = 0; i < this._typedRegistries.length; i++) { + const reg = this._typedRegistries[i]; + if (reg.isForType(type)) { + return reg; } } + return this.plugins; } - function _updateBezierControlPoints(points, options, area, loop) { - let i, ilen, point, controlPoints; - if (options.spanGaps) { - points = points.filter(function (pt) { - return !pt.skip; - }); + _get(id, typedRegistry, type) { + const item = typedRegistry.get(id); + if (item === undefined) { + throw new Error('"' + id + '" is not a registered ' + type + '.'); } - if (options.cubicInterpolationMode === 'monotone') { - splineCurveMonotone(points); - } else { - let prev = loop ? points[points.length - 1] : points[0]; - for (i = 0, ilen = points.length; i < ilen; ++i) { - point = points[i]; - controlPoints = splineCurve(prev, point, points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen], options.tension); - point.controlPointPreviousX = controlPoints.previous.x; - point.controlPointPreviousY = controlPoints.previous.y; - point.controlPointNextX = controlPoints.next.x; - point.controlPointNextY = controlPoints.next.y; - prev = point; + return item; + } +} +var registry = new Registry(); + +class PluginService { + constructor() { + this._init = []; + } + notify(chart, hook, args, filter) { + if (hook === 'beforeInit') { + this._init = this._createDescriptors(chart, true); + this._notify(this._init, chart, 'install'); + } + const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart); + const result = this._notify(descriptors, chart, hook, args); + if (hook === 'afterDestroy') { + this._notify(descriptors, chart, 'stop'); + this._notify(this._init, chart, 'uninstall'); + } + return result; + } + _notify(descriptors, chart, hook, args) { + args = args || {}; + for (const descriptor of descriptors) { + const plugin = descriptor.plugin; + const method = plugin[hook]; + const params = [chart, args, descriptor.options]; + if (callback(method, params, plugin) === false && args.cancelable) { + return false; } } - if (options.capBezierPoints) { - capBezierPoints(points, area); + return true; + } + invalidate() { + if (!isNullOrUndef(this._cache)) { + this._oldCache = this._cache; + this._cache = undefined; } } - - function _pointInLine(p1, p2, t, mode) { - return { - x: p1.x + t * (p2.x - p1.x), - y: p1.y + t * (p2.y - p1.y) - }; + _descriptors(chart) { + if (this._cache) { + return this._cache; + } + const descriptors = this._cache = this._createDescriptors(chart); + this._notifyStateChanges(chart); + return descriptors; + } + _createDescriptors(chart, all) { + const config = chart && chart.config; + const options = valueOrDefault(config.options && config.options.plugins, {}); + const plugins = allPlugins(config); + return options === false && !all ? [] : createDescriptors(chart, plugins, options, all); + } + _notifyStateChanges(chart) { + const previousDescriptors = this._oldCache || []; + const descriptors = this._cache; + const diff = (a, b) => a.filter(x => !b.some(y => x.plugin.id === y.plugin.id)); + this._notify(diff(previousDescriptors, descriptors), chart, 'stop'); + this._notify(diff(descriptors, previousDescriptors), chart, 'start'); + } +} +function allPlugins(config) { + const localIds = {}; + const plugins = []; + const keys = Object.keys(registry.plugins.items); + for (let i = 0; i < keys.length; i++) { + plugins.push(registry.getPlugin(keys[i])); + } + const local = config.plugins || []; + for (let i = 0; i < local.length; i++) { + const plugin = local[i]; + if (plugins.indexOf(plugin) === -1) { + plugins.push(plugin); + localIds[plugin.id] = true; + } + } + return {plugins, localIds}; +} +function getOpts(options, all) { + if (!all && options === false) { + return null; } - function _steppedInterpolation(p1, p2, t, mode) { - return { - x: p1.x + t * (p2.x - p1.x), - y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y : mode === 'after' ? t < 1 ? p1.y : p2.y : t > 0 ? p2.y : p1.y - }; + if (options === true) { + return {}; + } + return options; +} +function createDescriptors(chart, {plugins, localIds}, options, all) { + const result = []; + const context = chart.getContext(); + for (const plugin of plugins) { + const id = plugin.id; + const opts = getOpts(options[id], all); + if (opts === null) { + continue; + } + result.push({ + plugin, + options: pluginOpts(chart.config, {plugin, local: localIds[id]}, opts, context) + }); } - function _bezierInterpolation(p1, p2, t, mode) { - const cp1 = { - x: p1.controlPointNextX, - y: p1.controlPointNextY - }; - const cp2 = { - x: p2.controlPointPreviousX, - y: p2.controlPointPreviousY - }; - const a = _pointInLine(p1, cp1, t); - const b = _pointInLine(cp1, cp2, t); - const c = _pointInLine(cp2, p2, t); - const d = _pointInLine(a, b, t); - const e = _pointInLine(b, c, t); - return _pointInLine(d, e, t); + return result; +} +function pluginOpts(config, {plugin, local}, opts, context) { + const keys = config.pluginScopeKeys(plugin); + const scopes = config.getOptionScopes(opts, keys); + if (local && plugin.defaults) { + scopes.push(plugin.defaults); + } + return config.createResolver(scopes, context, [''], { + scriptable: false, + indexable: false, + allKeys: true + }); +} + +function getIndexAxis(type, options) { + const datasetDefaults = defaults.datasets[type] || {}; + const datasetOptions = (options.datasets || {})[type] || {}; + return datasetOptions.indexAxis || options.indexAxis || datasetDefaults.indexAxis || 'x'; +} +function getAxisFromDefaultScaleID(id, indexAxis) { + let axis = id; + if (id === '_index_') { + axis = indexAxis; + } else if (id === '_value_') { + axis = indexAxis === 'x' ? 'y' : 'x'; + } + return axis; +} +function getDefaultScaleIDFromAxis(axis, indexAxis) { + return axis === indexAxis ? '_index_' : '_value_'; +} +function axisFromPosition(position) { + if (position === 'top' || position === 'bottom') { + return 'x'; + } + if (position === 'left' || position === 'right') { + return 'y'; + } +} +function determineAxis(id, scaleOptions) { + if (id === 'x' || id === 'y') { + return id; + } + return scaleOptions.axis || axisFromPosition(scaleOptions.position) || id.charAt(0).toLowerCase(); +} +function mergeScaleConfig(config, options) { + const chartDefaults = overrides[config.type] || {scales: {}}; + const configScales = options.scales || {}; + const chartIndexAxis = getIndexAxis(config.type, options); + const firstIDs = Object.create(null); + const scales = Object.create(null); + Object.keys(configScales).forEach(id => { + const scaleConf = configScales[id]; + if (!isObject(scaleConf)) { + return console.error(`Invalid scale configuration for scale: ${id}`); + } + if (scaleConf._proxy) { + return console.warn(`Ignoring resolver passed as options for scale: ${id}`); + } + const axis = determineAxis(id, scaleConf); + const defaultId = getDefaultScaleIDFromAxis(axis, chartIndexAxis); + const defaultScaleOptions = chartDefaults.scales || {}; + firstIDs[axis] = firstIDs[axis] || id; + scales[id] = mergeIf(Object.create(null), [{axis}, scaleConf, defaultScaleOptions[axis], defaultScaleOptions[defaultId]]); + }); + config.data.datasets.forEach(dataset => { + const type = dataset.type || config.type; + const indexAxis = dataset.indexAxis || getIndexAxis(type, options); + const datasetDefaults = overrides[type] || {}; + const defaultScaleOptions = datasetDefaults.scales || {}; + Object.keys(defaultScaleOptions).forEach(defaultID => { + const axis = getAxisFromDefaultScaleID(defaultID, indexAxis); + const id = dataset[axis + 'AxisID'] || firstIDs[axis] || axis; + scales[id] = scales[id] || Object.create(null); + mergeIf(scales[id], [{axis}, configScales[id], defaultScaleOptions[defaultID]]); + }); + }); + Object.keys(scales).forEach(key => { + const scale = scales[key]; + mergeIf(scale, [defaults.scales[scale.type], defaults.scale]); + }); + return scales; +} +function initOptions(config) { + const options = config.options || (config.options = {}); + options.plugins = valueOrDefault(options.plugins, {}); + options.scales = mergeScaleConfig(config, options); +} +function initData(data) { + data = data || {}; + data.datasets = data.datasets || []; + data.labels = data.labels || []; + return data; +} +function initConfig(config) { + config = config || {}; + config.data = initData(config.data); + initOptions(config); + return config; +} +const keyCache = new Map(); +const keysCached = new Set(); +function cachedKeys(cacheKey, generate) { + let keys = keyCache.get(cacheKey); + if (!keys) { + keys = generate(); + keyCache.set(cacheKey, keys); + keysCached.add(keys); + } + return keys; +} +const addIfFound = (set, obj, key) => { + const opts = resolveObjectKey(obj, key); + if (opts !== undefined) { + set.add(opts); + } +}; +class Config { + constructor(config) { + this._config = initConfig(config); + this._scopeCache = new Map(); + this._resolverCache = new Map(); + } + get platform() { + return this._config.platform; + } + get type() { + return this._config.type; + } + set type(type) { + this._config.type = type; + } + get data() { + return this._config.data; + } + set data(data) { + this._config.data = initData(data); + } + get options() { + return this._config.options; + } + set options(options) { + this._config.options = options; + } + get plugins() { + return this._config.plugins; + } + update() { + const config = this._config; + this.clearCache(); + initOptions(config); + } + clearCache() { + this._scopeCache.clear(); + this._resolverCache.clear(); + } + datasetScopeKeys(datasetType) { + return cachedKeys(datasetType, + () => [[ + `datasets.${datasetType}`, + '' + ]]); + } + datasetAnimationScopeKeys(datasetType, transition) { + return cachedKeys(`${datasetType}.transition.${transition}`, + () => [ + [ + `datasets.${datasetType}.transitions.${transition}`, + `transitions.${transition}`, + ], + [ + `datasets.${datasetType}`, + '' + ] + ]); + } + datasetElementScopeKeys(datasetType, elementType) { + return cachedKeys(`${datasetType}-${elementType}`, + () => [[ + `datasets.${datasetType}.elements.${elementType}`, + `datasets.${datasetType}`, + `elements.${elementType}`, + '' + ]]); + } + pluginScopeKeys(plugin) { + const id = plugin.id; + const type = this.type; + return cachedKeys(`${type}-plugin-${id}`, + () => [[ + `plugins.${id}`, + ...plugin.additionalOptionScopes || [], + ]]); + } + _cachedScopes(mainScope, resetCache) { + const _scopeCache = this._scopeCache; + let cache = _scopeCache.get(mainScope); + if (!cache || resetCache) { + cache = new Map(); + _scopeCache.set(mainScope, cache); + } + return cache; + } + getOptionScopes(mainScope, keyLists, resetCache) { + const {options, type} = this; + const cache = this._cachedScopes(mainScope, resetCache); + const cached = cache.get(keyLists); + if (cached) { + return cached; + } + const scopes = new Set(); + keyLists.forEach(keys => { + if (mainScope) { + scopes.add(mainScope); + keys.forEach(key => addIfFound(scopes, mainScope, key)); + } + keys.forEach(key => addIfFound(scopes, options, key)); + keys.forEach(key => addIfFound(scopes, overrides[type] || {}, key)); + keys.forEach(key => addIfFound(scopes, defaults, key)); + keys.forEach(key => addIfFound(scopes, descriptors, key)); + }); + const array = Array.from(scopes); + if (array.length === 0) { + array.push(Object.create(null)); + } + if (keysCached.has(keyLists)) { + cache.set(keyLists, array); + } + return array; + } + chartOptionScopes() { + const {options, type} = this; + return [ + options, + overrides[type] || {}, + defaults.datasets[type] || {}, + {type}, + defaults, + descriptors + ]; + } + resolveNamedOptions(scopes, names, context, prefixes = ['']) { + const result = {$shared: true}; + const {resolver, subPrefixes} = getResolver(this._resolverCache, scopes, prefixes); + let options = resolver; + if (needContext(resolver, names)) { + result.$shared = false; + context = isFunction(context) ? context() : context; + const subResolver = this.createResolver(scopes, context, subPrefixes); + options = _attachContext(resolver, context, subResolver); + } + for (const prop of names) { + result[prop] = options[prop]; + } + return result; } + createResolver(scopes, context, prefixes = [''], descriptorDefaults) { + const {resolver} = getResolver(this._resolverCache, scopes, prefixes); + return isObject(context) + ? _attachContext(resolver, context, undefined, descriptorDefaults) + : resolver; + } +} +function getResolver(resolverCache, scopes, prefixes) { + let cache = resolverCache.get(scopes); + if (!cache) { + cache = new Map(); + resolverCache.set(scopes, cache); + } + const cacheKey = prefixes.join(); + let cached = cache.get(cacheKey); + if (!cached) { + const resolver = _createResolver(scopes, prefixes); + cached = { + resolver, + subPrefixes: prefixes.filter(p => !p.toLowerCase().includes('hover')) + }; + cache.set(cacheKey, cached); + } + return cached; +} +const hasFunction = value => isObject(value) + && Object.getOwnPropertyNames(value).reduce((acc, key) => acc || isFunction(value[key]), false); +function needContext(proxy, names) { + const {isScriptable, isIndexable} = _descriptors(proxy); + for (const prop of names) { + const scriptable = isScriptable(prop); + const indexable = isIndexable(prop); + const value = (indexable || scriptable) && proxy[prop]; + if ((scriptable && (isFunction(value) || hasFunction(value))) + || (indexable && isArray(value))) { + return true; + } + } + return false; +} - const getRightToLeftAdapter = function getRightToLeftAdapter(rectX, width) { - return { - x: function x(_x) { - return rectX + rectX + width - _x; - }, - setWidth: function setWidth(w) { - width = w; - }, - textAlign: function textAlign(align) { - if (align === 'center') { - return align; - } - return align === 'right' ? 'left' : 'right'; - }, - xPlus: function xPlus(x, value) { - return x - value; - }, - leftForLtr: function leftForLtr(x, itemWidth) { - return x - itemWidth; - } - }; - }; - const getLeftToRightAdapter = function getLeftToRightAdapter() { - return { - x: function x(_x2) { - return _x2; - }, - setWidth: function setWidth(w) { - }, - textAlign: function textAlign(align) { - return align; - }, - xPlus: function xPlus(x, value) { - return x + value; - }, - leftForLtr: function leftForLtr(x, _itemWidth) { - return x; - } - }; +var version = "3.9.1"; + +const KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea']; +function positionIsHorizontal(position, axis) { + return position === 'top' || position === 'bottom' || (KNOWN_POSITIONS.indexOf(position) === -1 && axis === 'x'); +} +function compare2Level(l1, l2) { + return function(a, b) { + return a[l1] === b[l1] + ? a[l2] - b[l2] + : a[l1] - b[l1]; }; - function getRtlAdapter(rtl, rectX, width) { - return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter(); +} +function onAnimationsComplete(context) { + const chart = context.chart; + const animationOptions = chart.options.animation; + chart.notifyPlugins('afterRender'); + callback(animationOptions && animationOptions.onComplete, [context], chart); +} +function onAnimationProgress(context) { + const chart = context.chart; + const animationOptions = chart.options.animation; + callback(animationOptions && animationOptions.onProgress, [context], chart); +} +function getCanvas(item) { + if (_isDomSupported() && typeof item === 'string') { + item = document.getElementById(item); + } else if (item && item.length) { + item = item[0]; + } + if (item && item.canvas) { + item = item.canvas; + } + return item; +} +const instances = {}; +const getChart = (key) => { + const canvas = getCanvas(key); + return Object.values(instances).filter((c) => c.canvas === canvas).pop(); +}; +function moveNumericKeys(obj, start, move) { + const keys = Object.keys(obj); + for (const key of keys) { + const intKey = +key; + if (intKey >= start) { + const value = obj[key]; + delete obj[key]; + if (move > 0 || intKey > start) { + obj[intKey + move] = value; + } + } + } +} +function determineLastEvent(e, lastEvent, inChartArea, isClick) { + if (!inChartArea || e.type === 'mouseout') { + return null; } - function overrideTextDirection(ctx, direction) { - let style, original; - if (direction === 'ltr' || direction === 'rtl') { - style = ctx.canvas.style; - original = [style.getPropertyValue('direction'), style.getPropertyPriority('direction')]; - style.setProperty('direction', direction, 'important'); - ctx.prevTextDirection = original; + if (isClick) { + return lastEvent; + } + return e; +} +class Chart { + constructor(item, userConfig) { + const config = this.config = new Config(userConfig); + const initialCanvas = getCanvas(item); + const existingChart = getChart(initialCanvas); + if (existingChart) { + throw new Error( + 'Canvas is already in use. Chart with ID \'' + existingChart.id + '\'' + + ' must be destroyed before the canvas with ID \'' + existingChart.canvas.id + '\' can be reused.' + ); + } + const options = config.createResolver(config.chartOptionScopes(), this.getContext()); + this.platform = new (config.platform || _detectPlatform(initialCanvas))(); + this.platform.updateConfig(config); + const context = this.platform.acquireContext(initialCanvas, options.aspectRatio); + const canvas = context && context.canvas; + const height = canvas && canvas.height; + const width = canvas && canvas.width; + this.id = uid(); + this.ctx = context; + this.canvas = canvas; + this.width = width; + this.height = height; + this._options = options; + this._aspectRatio = this.aspectRatio; + this._layers = []; + this._metasets = []; + this._stacks = undefined; + this.boxes = []; + this.currentDevicePixelRatio = undefined; + this.chartArea = undefined; + this._active = []; + this._lastEvent = undefined; + this._listeners = {}; + this._responsiveListeners = undefined; + this._sortedMetasets = []; + this.scales = {}; + this._plugins = new PluginService(); + this.$proxies = {}; + this._hiddenIndices = {}; + this.attached = false; + this._animationsDisabled = undefined; + this.$context = undefined; + this._doResize = debounce(mode => this.update(mode), options.resizeDelay || 0); + this._dataChanges = []; + instances[this.id] = this; + if (!context || !canvas) { + console.error("Failed to create chart: can't acquire context from the given item"); + return; + } + animator.listen(this, 'complete', onAnimationsComplete); + animator.listen(this, 'progress', onAnimationProgress); + this._initialize(); + if (this.attached) { + this.update(); } } - function restoreTextDirection(ctx, original) { - if (original !== undefined) { - delete ctx.prevTextDirection; - ctx.canvas.style.setProperty('direction', original[0], original[1]); + get aspectRatio() { + const {options: {aspectRatio, maintainAspectRatio}, width, height, _aspectRatio} = this; + if (!isNullOrUndef(aspectRatio)) { + return aspectRatio; } + if (maintainAspectRatio && _aspectRatio) { + return _aspectRatio; + } + return height ? width / height : null; } - - function propertyFn(property) { - if (property === 'angle') { - return { - between: _angleBetween, - compare: _angleDiff, - normalize: _normalizeAngle - }; + get data() { + return this.config.data; + } + set data(data) { + this.config.data = data; + } + get options() { + return this._options; + } + set options(options) { + this.config.options = options; + } + _initialize() { + this.notifyPlugins('beforeInit'); + if (this.options.responsive) { + this.resize(); + } else { + retinaScale(this, this.options.devicePixelRatio); } - return { - between: function between(n, s, e) { - return n >= s && n <= e; - }, - compare: function compare(a, b) { - return a - b; - }, - normalize: function normalize(x) { - return x; + this.bindEvents(); + this.notifyPlugins('afterInit'); + return this; + } + clear() { + clearCanvas(this.canvas, this.ctx); + return this; + } + stop() { + animator.stop(this); + return this; + } + resize(width, height) { + if (!animator.running(this)) { + this._resize(width, height); + } else { + this._resizeBeforeDraw = {width, height}; + } + } + _resize(width, height) { + const options = this.options; + const canvas = this.canvas; + const aspectRatio = options.maintainAspectRatio && this.aspectRatio; + const newSize = this.platform.getMaximumSize(canvas, width, height, aspectRatio); + const newRatio = options.devicePixelRatio || this.platform.getDevicePixelRatio(); + const mode = this.width ? 'resize' : 'attach'; + this.width = newSize.width; + this.height = newSize.height; + this._aspectRatio = this.aspectRatio; + if (!retinaScale(this, newRatio, true)) { + return; + } + this.notifyPlugins('resize', {size: newSize}); + callback(options.onResize, [this, newSize], this); + if (this.attached) { + if (this._doResize(mode)) { + this.render(); } - }; + } } - function makeSubSegment(start, end, loop, count) { - return { - start: start % count, - end: end % count, - loop: loop && (end - start + 1) % count === 0 - }; + ensureScalesHaveIDs() { + const options = this.options; + const scalesOptions = options.scales || {}; + each(scalesOptions, (axisOptions, axisID) => { + axisOptions.id = axisID; + }); } - function getSegment(segment, points, bounds) { - const property = bounds.property, - startBound = bounds.start, - endBound = bounds.end; - const _propertyFn = propertyFn(property), - between = _propertyFn.between, - normalize = _propertyFn.normalize; - const count = points.length; - let start = segment.start, - end = segment.end, - loop = segment.loop; - let i, ilen; - if (loop) { - start += count; - end += count; - for (i = 0, ilen = count; i < ilen; ++i) { - if (!between(normalize(points[start % count][property]), startBound, endBound)) { - break; - } - start--; - end--; + buildOrUpdateScales() { + const options = this.options; + const scaleOpts = options.scales; + const scales = this.scales; + const updated = Object.keys(scales).reduce((obj, id) => { + obj[id] = false; + return obj; + }, {}); + let items = []; + if (scaleOpts) { + items = items.concat( + Object.keys(scaleOpts).map((id) => { + const scaleOptions = scaleOpts[id]; + const axis = determineAxis(id, scaleOptions); + const isRadial = axis === 'r'; + const isHorizontal = axis === 'x'; + return { + options: scaleOptions, + dposition: isRadial ? 'chartArea' : isHorizontal ? 'bottom' : 'left', + dtype: isRadial ? 'radialLinear' : isHorizontal ? 'category' : 'linear' + }; + }) + ); + } + each(items, (item) => { + const scaleOptions = item.options; + const id = scaleOptions.id; + const axis = determineAxis(id, scaleOptions); + const scaleType = valueOrDefault(scaleOptions.type, item.dtype); + if (scaleOptions.position === undefined || positionIsHorizontal(scaleOptions.position, axis) !== positionIsHorizontal(item.dposition)) { + scaleOptions.position = item.dposition; + } + updated[id] = true; + let scale = null; + if (id in scales && scales[id].type === scaleType) { + scale = scales[id]; + } else { + const scaleClass = registry.getScale(scaleType); + scale = new scaleClass({ + id, + type: scaleType, + ctx: this.ctx, + chart: this + }); + scales[scale.id] = scale; + } + scale.init(scaleOptions, options); + }); + each(updated, (hasUpdated, id) => { + if (!hasUpdated) { + delete scales[id]; + } + }); + each(scales, (scale) => { + layouts.configure(this, scale, scale.options); + layouts.addBox(this, scale); + }); + } + _updateMetasets() { + const metasets = this._metasets; + const numData = this.data.datasets.length; + const numMeta = metasets.length; + metasets.sort((a, b) => a.index - b.index); + if (numMeta > numData) { + for (let i = numData; i < numMeta; ++i) { + this._destroyDatasetMeta(i); } - start %= count; - end %= count; + metasets.splice(numData, numMeta - numData); } - if (end < start) { - end += count; + this._sortedMetasets = metasets.slice(0).sort(compare2Level('order', 'index')); + } + _removeUnreferencedMetasets() { + const {_metasets: metasets, data: {datasets}} = this; + if (metasets.length > datasets.length) { + delete this._stacks; } - return { - start: start, - end: end, - loop: loop - }; + metasets.forEach((meta, index) => { + if (datasets.filter(x => x === meta._dataset).length === 0) { + this._destroyDatasetMeta(index); + } + }); } - function _boundSegment(segment, points, bounds) { - if (!bounds) { - return [segment]; - } - const property = bounds.property, - startBound = bounds.start, - endBound = bounds.end; - const count = points.length; - const _propertyFn2 = propertyFn(property), - compare = _propertyFn2.compare, - between = _propertyFn2.between, - normalize = _propertyFn2.normalize; - const _getSegment = getSegment(segment, points, bounds), - start = _getSegment.start, - end = _getSegment.end, - loop = _getSegment.loop; - const result = []; - let inside = false; - let subStart = null; - let value, point, prevValue; - const startIsBefore = function startIsBefore() { - return between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0; - }; - const endIsBefore = function endIsBefore() { - return compare(endBound, value) === 0 || between(endBound, prevValue, value); - }; - const shouldStart = function shouldStart() { - return inside || startIsBefore(); - }; - const shouldStop = function shouldStop() { - return !inside || endIsBefore(); - }; - for (let i = start, prev = start; i <= end; ++i) { - point = points[i % count]; - if (point.skip) { - continue; + buildOrUpdateControllers() { + const newControllers = []; + const datasets = this.data.datasets; + let i, ilen; + this._removeUnreferencedMetasets(); + for (i = 0, ilen = datasets.length; i < ilen; i++) { + const dataset = datasets[i]; + let meta = this.getDatasetMeta(i); + const type = dataset.type || this.config.type; + if (meta.type && meta.type !== type) { + this._destroyDatasetMeta(i); + meta = this.getDatasetMeta(i); + } + meta.type = type; + meta.indexAxis = dataset.indexAxis || getIndexAxis(type, this.options); + meta.order = dataset.order || 0; + meta.index = i; + meta.label = '' + dataset.label; + meta.visible = this.isDatasetVisible(i); + if (meta.controller) { + meta.controller.updateIndex(i); + meta.controller.linkScales(); + } else { + const ControllerClass = registry.getController(type); + const {datasetElementType, dataElementType} = defaults.datasets[type]; + Object.assign(ControllerClass.prototype, { + dataElementType: registry.getElement(dataElementType), + datasetElementType: datasetElementType && registry.getElement(datasetElementType) + }); + meta.controller = new ControllerClass(this, i); + newControllers.push(meta.controller); + } + } + this._updateMetasets(); + return newControllers; + } + _resetElements() { + each(this.data.datasets, (dataset, datasetIndex) => { + this.getDatasetMeta(datasetIndex).controller.reset(); + }, this); + } + reset() { + this._resetElements(); + this.notifyPlugins('reset'); + } + update(mode) { + const config = this.config; + config.update(); + const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext()); + const animsDisabled = this._animationsDisabled = !options.animation; + this._updateScales(); + this._checkEventBindings(); + this._updateHiddenIndices(); + this._plugins.invalidate(); + if (this.notifyPlugins('beforeUpdate', {mode, cancelable: true}) === false) { + return; + } + const newControllers = this.buildOrUpdateControllers(); + this.notifyPlugins('beforeElementsUpdate'); + let minPadding = 0; + for (let i = 0, ilen = this.data.datasets.length; i < ilen; i++) { + const {controller} = this.getDatasetMeta(i); + const reset = !animsDisabled && newControllers.indexOf(controller) === -1; + controller.buildOrUpdateElements(reset); + minPadding = Math.max(+controller.getMaxOverflow(), minPadding); + } + minPadding = this._minPadding = options.layout.autoPadding ? minPadding : 0; + this._updateLayout(minPadding); + if (!animsDisabled) { + each(newControllers, (controller) => { + controller.reset(); + }); + } + this._updateDatasets(mode); + this.notifyPlugins('afterUpdate', {mode}); + this._layers.sort(compare2Level('z', '_idx')); + const {_active, _lastEvent} = this; + if (_lastEvent) { + this._eventHandler(_lastEvent, true); + } else if (_active.length) { + this._updateHoverStyles(_active, _active, true); + } + this.render(); + } + _updateScales() { + each(this.scales, (scale) => { + layouts.removeBox(this, scale); + }); + this.ensureScalesHaveIDs(); + this.buildOrUpdateScales(); + } + _checkEventBindings() { + const options = this.options; + const existingEvents = new Set(Object.keys(this._listeners)); + const newEvents = new Set(options.events); + if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) { + this.unbindEvents(); + this.bindEvents(); + } + } + _updateHiddenIndices() { + const {_hiddenIndices} = this; + const changes = this._getUniformDataChanges() || []; + for (const {method, start, count} of changes) { + const move = method === '_removeElements' ? -count : count; + moveNumericKeys(_hiddenIndices, start, move); + } + } + _getUniformDataChanges() { + const _dataChanges = this._dataChanges; + if (!_dataChanges || !_dataChanges.length) { + return; + } + this._dataChanges = []; + const datasetCount = this.data.datasets.length; + const makeSet = (idx) => new Set( + _dataChanges + .filter(c => c[0] === idx) + .map((c, i) => i + ',' + c.splice(1).join(',')) + ); + const changeSet = makeSet(0); + for (let i = 1; i < datasetCount; i++) { + if (!setsEqual(changeSet, makeSet(i))) { + return; } - value = normalize(point[property]); - inside = between(value, startBound, endBound); - if (subStart === null && shouldStart()) { - subStart = compare(value, startBound) === 0 ? i : prev; + } + return Array.from(changeSet) + .map(c => c.split(',')) + .map(a => ({method: a[1], start: +a[2], count: +a[3]})); + } + _updateLayout(minPadding) { + if (this.notifyPlugins('beforeLayout', {cancelable: true}) === false) { + return; + } + layouts.update(this, this.width, this.height, minPadding); + const area = this.chartArea; + const noArea = area.width <= 0 || area.height <= 0; + this._layers = []; + each(this.boxes, (box) => { + if (noArea && box.position === 'chartArea') { + return; } - if (subStart !== null && shouldStop()) { - result.push(makeSubSegment(subStart, i, loop, count)); - subStart = null; + if (box.configure) { + box.configure(); } - prev = i; - prevValue = value; + this._layers.push(...box._layers()); + }, this); + this._layers.forEach((item, index) => { + item._idx = index; + }); + this.notifyPlugins('afterLayout'); + } + _updateDatasets(mode) { + if (this.notifyPlugins('beforeDatasetsUpdate', {mode, cancelable: true}) === false) { + return; + } + for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) { + this.getDatasetMeta(i).controller.configure(); } - if (subStart !== null) { - result.push(makeSubSegment(subStart, end, loop, count)); + for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) { + this._updateDataset(i, isFunction(mode) ? mode({datasetIndex: i}) : mode); } - return result; + this.notifyPlugins('afterDatasetsUpdate', {mode}); } - function _boundSegments(line, bounds) { - const result = []; - const segments = line.segments; - for (let i = 0; i < segments.length; i++) { - const sub = _boundSegment(segments[i], line.points, bounds); - if (sub.length) { - result.push.apply(result, sub); - } + _updateDataset(index, mode) { + const meta = this.getDatasetMeta(index); + const args = {meta, index, mode, cancelable: true}; + if (this.notifyPlugins('beforeDatasetUpdate', args) === false) { + return; } - return result; + meta.controller._update(mode); + args.cancelable = false; + this.notifyPlugins('afterDatasetUpdate', args); } - function findStartAndEnd(points, count, loop, spanGaps) { - let start = 0; - let end = count - 1; - if (loop && !spanGaps) { - while (start < count && !points[start].skip) { - start++; + render() { + if (this.notifyPlugins('beforeRender', {cancelable: true}) === false) { + return; + } + if (animator.has(this)) { + if (this.attached && !animator.running(this)) { + animator.start(this); } + } else { + this.draw(); + onAnimationsComplete({chart: this}); } - while (start < count && points[start].skip) { - start++; + } + draw() { + let i; + if (this._resizeBeforeDraw) { + const {width, height} = this._resizeBeforeDraw; + this._resize(width, height); + this._resizeBeforeDraw = null; } - start %= count; - if (loop) { - end += start; + this.clear(); + if (this.width <= 0 || this.height <= 0) { + return; } - while (end > start && points[end % count].skip) { - end--; + if (this.notifyPlugins('beforeDraw', {cancelable: true}) === false) { + return; } - end %= count; - return { - start: start, - end: end - }; + const layers = this._layers; + for (i = 0; i < layers.length && layers[i].z <= 0; ++i) { + layers[i].draw(this.chartArea); + } + this._drawDatasets(); + for (; i < layers.length; ++i) { + layers[i].draw(this.chartArea); + } + this.notifyPlugins('afterDraw'); } - function solidSegments(points, start, max, loop) { - const count = points.length; + _getSortedDatasetMetas(filterVisible) { + const metasets = this._sortedMetasets; const result = []; - let last = start; - let prev = points[start]; - let end; - for (end = start + 1; end <= max; ++end) { - const cur = points[end % count]; - if (cur.skip || cur.stop) { - if (!prev.skip) { - loop = false; - result.push({ - start: start % count, - end: (end - 1) % count, - loop: loop - }); - start = last = cur.stop ? end : null; - } - } else { - last = end; - if (prev.skip) { - start = end; - } + let i, ilen; + for (i = 0, ilen = metasets.length; i < ilen; ++i) { + const meta = metasets[i]; + if (!filterVisible || meta.visible) { + result.push(meta); } - prev = cur; - } - if (last !== null) { - result.push({ - start: start % count, - end: last % count, - loop: loop - }); } return result; } - function _computeSegments(line) { - const points = line.points; - const spanGaps = line.options.spanGaps; - const count = points.length; - if (!count) { - return []; + getSortedVisibleDatasetMetas() { + return this._getSortedDatasetMetas(true); + } + _drawDatasets() { + if (this.notifyPlugins('beforeDatasetsDraw', {cancelable: true}) === false) { + return; } - const loop = !!line._loop; - const _findStartAndEnd = findStartAndEnd(points, count, loop, spanGaps), - start = _findStartAndEnd.start, - end = _findStartAndEnd.end; - if (spanGaps === true) { - return [{ - start: start, - end: end, - loop: loop - }]; + const metasets = this.getSortedVisibleDatasetMetas(); + for (let i = metasets.length - 1; i >= 0; --i) { + this._drawDataset(metasets[i]); } - const max = end < start ? end + count : end; - const completeLoop = !!line._fullLoop && start === 0 && end === count - 1; - return solidSegments(points, start, max, completeLoop); + this.notifyPlugins('afterDatasetsDraw'); } - - const helpers = /*#__PURE__*/Object.freeze({ - __proto__: null, - easingEffects: effects, - color: color, - getHoverColor: getHoverColor, - requestAnimFrame: requestAnimFrame, - fontString: fontString, - noop: noop, - uid: uid, - isNullOrUndef: isNullOrUndef, - isArray: isArray, - isObject: isObject, - isFinite: isNumberFinite, - valueOrDefault: valueOrDefault, - callback: callback, - each: each, - _elementsEqual: _elementsEqual, - clone: clone, - _merger: _merger, - merge: merge, - mergeIf: mergeIf, - _mergerIf: _mergerIf, - _deprecated: _deprecated, - resolveObjectKey: resolveObjectKey, - _capitalize: _capitalize, - toFontString: toFontString, - _measureText: _measureText, - _longestText: _longestText, - _alignPixel: _alignPixel, - clear: clear, - drawPoint: drawPoint, - _isPointInArea: _isPointInArea, - clipArea: clipArea, - unclipArea: unclipArea, - _steppedLineTo: _steppedLineTo, - _bezierCurveTo: _bezierCurveTo, - _lookup: _lookup, - _lookupByKey: _lookupByKey, - _rlookupByKey: _rlookupByKey, - _filterBetween: _filterBetween, - listenArrayEvents: listenArrayEvents, - unlistenArrayEvents: unlistenArrayEvents, - _arrayUnique: _arrayUnique, - splineCurve: splineCurve, - splineCurveMonotone: splineCurveMonotone, - _updateBezierControlPoints: _updateBezierControlPoints, - _getParentNode: _getParentNode, - getStyle: getStyle, - getRelativePosition: getRelativePosition, - getMaximumSize: getMaximumSize, - retinaScale: retinaScale, - supportsEventListenerOptions: supportsEventListenerOptions, - readUsedSize: readUsedSize, - _pointInLine: _pointInLine, - _steppedInterpolation: _steppedInterpolation, - _bezierInterpolation: _bezierInterpolation, - toLineHeight: toLineHeight, - toTRBL: toTRBL, - toTRBLCorners: toTRBLCorners, - toPadding: toPadding, - toFont: toFont, - resolve: resolve, - PI: PI, - TAU: TAU, - PITAU: PITAU, - INFINITY: INFINITY, - RAD_PER_DEG: RAD_PER_DEG, - HALF_PI: HALF_PI, - QUARTER_PI: QUARTER_PI, - TWO_THIRDS_PI: TWO_THIRDS_PI, - _factorize: _factorize, - log10: log10, - isNumber: isNumber, - almostEquals: almostEquals, - almostWhole: almostWhole, - _setMinAndMaxByKey: _setMinAndMaxByKey, - sign: sign, - toRadians: toRadians, - toDegrees: toDegrees, - _decimalPlaces: _decimalPlaces, - getAngleFromPoint: getAngleFromPoint, - distanceBetweenPoints: distanceBetweenPoints, - _angleDiff: _angleDiff, - _normalizeAngle: _normalizeAngle, - _angleBetween: _angleBetween, - _limitValue: _limitValue, - _int16Range: _int16Range, - getRtlAdapter: getRtlAdapter, - overrideTextDirection: overrideTextDirection, - restoreTextDirection: restoreTextDirection, - _boundSegment: _boundSegment, - _boundSegments: _boundSegments, - _computeSegments: _computeSegments - }); - - function abstract() { - throw new Error('This method is not implemented: either no adapter can be found or an incomplete integration was provided.'); + _drawDataset(meta) { + const ctx = this.ctx; + const clip = meta._clip; + const useClip = !clip.disabled; + const area = this.chartArea; + const args = { + meta, + index: meta.index, + cancelable: true + }; + if (this.notifyPlugins('beforeDatasetDraw', args) === false) { + return; + } + if (useClip) { + clipArea(ctx, { + left: clip.left === false ? 0 : area.left - clip.left, + right: clip.right === false ? this.width : area.right + clip.right, + top: clip.top === false ? 0 : area.top - clip.top, + bottom: clip.bottom === false ? this.height : area.bottom + clip.bottom + }); + } + meta.controller.draw(); + if (useClip) { + unclipArea(ctx); + } + args.cancelable = false; + this.notifyPlugins('afterDatasetDraw', args); + } + isPointInArea(point) { + return _isPointInArea(point, this.chartArea, this._minPadding); } - const DateAdapter = function () { - function DateAdapter(options) { - this.options = options || {}; + getElementsAtEventForMode(e, mode, options, useFinalPosition) { + const method = Interaction.modes[mode]; + if (typeof method === 'function') { + return method(this, e, options, useFinalPosition); } - const _proto = DateAdapter.prototype; - _proto.formats = function formats() { - return abstract(); + return []; + } + getDatasetMeta(datasetIndex) { + const dataset = this.data.datasets[datasetIndex]; + const metasets = this._metasets; + let meta = metasets.filter(x => x && x._dataset === dataset).pop(); + if (!meta) { + meta = { + type: null, + data: [], + dataset: null, + controller: null, + hidden: null, + xAxisID: null, + yAxisID: null, + order: dataset && dataset.order || 0, + index: datasetIndex, + _dataset: dataset, + _parsed: [], + _sorted: false + }; + metasets.push(meta); } - ; - _proto.parse = function parse(value, format) { - return abstract(); + return meta; + } + getContext() { + return this.$context || (this.$context = createContext(null, {chart: this, type: 'chart'})); + } + getVisibleDatasetCount() { + return this.getSortedVisibleDatasetMetas().length; + } + isDatasetVisible(datasetIndex) { + const dataset = this.data.datasets[datasetIndex]; + if (!dataset) { + return false; } - ; - _proto.format = function format(timestamp, _format) { - return abstract(); + const meta = this.getDatasetMeta(datasetIndex); + return typeof meta.hidden === 'boolean' ? !meta.hidden : !dataset.hidden; + } + setDatasetVisibility(datasetIndex, visible) { + const meta = this.getDatasetMeta(datasetIndex); + meta.hidden = !visible; + } + toggleDataVisibility(index) { + this._hiddenIndices[index] = !this._hiddenIndices[index]; + } + getDataVisibility(index) { + return !this._hiddenIndices[index]; + } + _updateVisibility(datasetIndex, dataIndex, visible) { + const mode = visible ? 'show' : 'hide'; + const meta = this.getDatasetMeta(datasetIndex); + const anims = meta.controller._resolveAnimations(undefined, mode); + if (defined(dataIndex)) { + meta.data[dataIndex].hidden = !visible; + this.update(); + } else { + this.setDatasetVisibility(datasetIndex, visible); + anims.update(meta, {visible}); + this.update((ctx) => ctx.datasetIndex === datasetIndex ? mode : undefined); } - ; - _proto.add = function add(timestamp, amount, unit) { - return abstract(); + } + hide(datasetIndex, dataIndex) { + this._updateVisibility(datasetIndex, dataIndex, false); + } + show(datasetIndex, dataIndex) { + this._updateVisibility(datasetIndex, dataIndex, true); + } + _destroyDatasetMeta(datasetIndex) { + const meta = this._metasets[datasetIndex]; + if (meta && meta.controller) { + meta.controller._destroy(); } - ; - _proto.diff = function diff(a, b, unit) { - return abstract(); + delete this._metasets[datasetIndex]; + } + _stop() { + let i, ilen; + this.stop(); + animator.remove(this); + for (i = 0, ilen = this.data.datasets.length; i < ilen; ++i) { + this._destroyDatasetMeta(i); + } + } + destroy() { + this.notifyPlugins('beforeDestroy'); + const {canvas, ctx} = this; + this._stop(); + this.config.clearCache(); + if (canvas) { + this.unbindEvents(); + clearCanvas(canvas, ctx); + this.platform.releaseContext(ctx); + this.canvas = null; + this.ctx = null; + } + this.notifyPlugins('destroy'); + delete instances[this.id]; + this.notifyPlugins('afterDestroy'); + } + toBase64Image(...args) { + return this.canvas.toDataURL(...args); + } + bindEvents() { + this.bindUserEvents(); + if (this.options.responsive) { + this.bindResponsiveEvents(); + } else { + this.attached = true; } - ; - _proto.startOf = function startOf(timestamp, unit, weekday) { - return abstract(); + } + bindUserEvents() { + const listeners = this._listeners; + const platform = this.platform; + const _add = (type, listener) => { + platform.addEventListener(this, type, listener); + listeners[type] = listener; + }; + const listener = (e, x, y) => { + e.offsetX = x; + e.offsetY = y; + this._eventHandler(e); + }; + each(this.options.events, (type) => _add(type, listener)); + } + bindResponsiveEvents() { + if (!this._responsiveListeners) { + this._responsiveListeners = {}; } - ; - _proto.endOf = function endOf(timestamp, unit) { - return abstract(); + const listeners = this._responsiveListeners; + const platform = this.platform; + const _add = (type, listener) => { + platform.addEventListener(this, type, listener); + listeners[type] = listener; }; - return DateAdapter; - }(); - DateAdapter.override = function (members) { - _extends(DateAdapter.prototype, members); - }; - const _adapters = { - _date: DateAdapter - }; - - function getAllScaleValues(scale) { - if (!scale._cache.$bar) { - const metas = scale.getMatchingVisibleMetas('bar'); - let values = []; - for (let i = 0, ilen = metas.length; i < ilen; i++) { - values = values.concat(metas[i].controller.getAllParsedValues(scale)); - } - scale._cache.$bar = _arrayUnique(values.sort(function (a, b) { - return a - b; - })); - } - return scale._cache.$bar; - } - function computeMinSampleSize(scale) { - const values = getAllScaleValues(scale); - let min = scale._length; - let i, ilen, curr, prev; - const updateMinAndPrev = function updateMinAndPrev() { - min = Math.min(min, i && Math.abs(curr - prev) || min); - prev = curr; + const _remove = (type, listener) => { + if (listeners[type]) { + platform.removeEventListener(this, type, listener); + delete listeners[type]; + } + }; + const listener = (width, height) => { + if (this.canvas) { + this.resize(width, height); + } }; - for (i = 0, ilen = values.length; i < ilen; ++i) { - curr = scale.getPixelForValue(values[i]); - updateMinAndPrev(); - } - for (i = 0, ilen = scale.ticks.length; i < ilen; ++i) { - curr = scale.getPixelForTick(i); - updateMinAndPrev(); - } - return min; - } - function computeFitCategoryTraits(index, ruler, options, stackCount) { - const thickness = options.barThickness; - let size, ratio; - if (isNullOrUndef(thickness)) { - size = ruler.min * options.categoryPercentage; - ratio = options.barPercentage; + let detached; + const attached = () => { + _remove('attach', attached); + this.attached = true; + this.resize(); + _add('resize', listener); + _add('detach', detached); + }; + detached = () => { + this.attached = false; + _remove('resize', listener); + this._stop(); + this._resize(0, 0); + _add('attach', attached); + }; + if (platform.isAttached(this.canvas)) { + attached(); } else { - size = thickness * stackCount; - ratio = 1; + detached(); } - return { - chunk: size / stackCount, - ratio: ratio, - start: ruler.pixels[index] - size / 2 - }; } - function computeFlexCategoryTraits(index, ruler, options, stackCount) { - const pixels = ruler.pixels; - const curr = pixels[index]; - let prev = index > 0 ? pixels[index - 1] : null; - let next = index < pixels.length - 1 ? pixels[index + 1] : null; - const percent = options.categoryPercentage; - if (prev === null) { - prev = curr - (next === null ? ruler.end - ruler.start : next - curr); + unbindEvents() { + each(this._listeners, (listener, type) => { + this.platform.removeEventListener(this, type, listener); + }); + this._listeners = {}; + each(this._responsiveListeners, (listener, type) => { + this.platform.removeEventListener(this, type, listener); + }); + this._responsiveListeners = undefined; + } + updateHoverStyle(items, mode, enabled) { + const prefix = enabled ? 'set' : 'remove'; + let meta, item, i, ilen; + if (mode === 'dataset') { + meta = this.getDatasetMeta(items[0].datasetIndex); + meta.controller['_' + prefix + 'DatasetHoverStyle'](); } - if (next === null) { - next = curr + curr - prev; + for (i = 0, ilen = items.length; i < ilen; ++i) { + item = items[i]; + const controller = item && this.getDatasetMeta(item.datasetIndex).controller; + if (controller) { + controller[prefix + 'HoverStyle'](item.element, item.datasetIndex, item.index); + } } - const start = curr - (curr - Math.min(prev, next)) / 2 * percent; - const size = Math.abs(next - prev) / 2 * percent; - return { - chunk: size / stackCount, - ratio: options.barPercentage, - start: start - }; } - function parseFloatBar(entry, item, vScale, i) { - const startValue = vScale.parse(entry[0], i); - const endValue = vScale.parse(entry[1], i); - const min = Math.min(startValue, endValue); - const max = Math.max(startValue, endValue); - let barStart = min; - let barEnd = max; - if (Math.abs(min) > Math.abs(max)) { - barStart = max; - barEnd = min; - } - item[vScale.axis] = barEnd; - item._custom = { - barStart: barStart, - barEnd: barEnd, - start: startValue, - end: endValue, - min: min, - max: max - }; + getActiveElements() { + return this._active || []; } - function parseValue(entry, item, vScale, i) { - if (isArray(entry)) { - parseFloatBar(entry, item, vScale, i); - } else { - item[vScale.axis] = vScale.parse(entry, i); + setActiveElements(activeElements) { + const lastActive = this._active || []; + const active = activeElements.map(({datasetIndex, index}) => { + const meta = this.getDatasetMeta(datasetIndex); + if (!meta) { + throw new Error('No dataset found at index ' + datasetIndex); + } + return { + datasetIndex, + element: meta.data[index], + index, + }; + }); + const changed = !_elementsEqual(active, lastActive); + if (changed) { + this._active = active; + this._lastEvent = null; + this._updateHoverStyles(active, lastActive); } - return item; } - function parseArrayOrPrimitive(meta, data, start, count) { - const iScale = meta.iScale; - const vScale = meta.vScale; - const labels = iScale.getLabels(); - const singleScale = iScale === vScale; + notifyPlugins(hook, args, filter) { + return this._plugins.notify(this, hook, args, filter); + } + _updateHoverStyles(active, lastActive, replay) { + const hoverOptions = this.options.hover; + const diff = (a, b) => a.filter(x => !b.some(y => x.datasetIndex === y.datasetIndex && x.index === y.index)); + const deactivated = diff(lastActive, active); + const activated = replay ? active : diff(active, lastActive); + if (deactivated.length) { + this.updateHoverStyle(deactivated, hoverOptions.mode, false); + } + if (activated.length && hoverOptions.mode) { + this.updateHoverStyle(activated, hoverOptions.mode, true); + } + } + _eventHandler(e, replay) { + const args = { + event: e, + replay, + cancelable: true, + inChartArea: this.isPointInArea(e) + }; + const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type); + if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) { + return; + } + const changed = this._handleEvent(e, replay, args.inChartArea); + args.cancelable = false; + this.notifyPlugins('afterEvent', args, eventFilter); + if (changed || args.changed) { + this.render(); + } + return this; + } + _handleEvent(e, replay, inChartArea) { + const {_active: lastActive = [], options} = this; + const useFinalPosition = replay; + const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition); + const isClick = _isClickEvent(e); + const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick); + if (inChartArea) { + this._lastEvent = null; + callback(options.onHover, [e, active, this], this); + if (isClick) { + callback(options.onClick, [e, active, this], this); + } + } + const changed = !_elementsEqual(active, lastActive); + if (changed || replay) { + this._active = active; + this._updateHoverStyles(active, lastActive, replay); + } + this._lastEvent = lastEvent; + return changed; + } + _getActiveElements(e, lastActive, inChartArea, useFinalPosition) { + if (e.type === 'mouseout') { + return []; + } + if (!inChartArea) { + return lastActive; + } + const hoverOptions = this.options.hover; + return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition); + } +} +const invalidatePlugins = () => each(Chart.instances, (chart) => chart._plugins.invalidate()); +const enumerable = true; +Object.defineProperties(Chart, { + defaults: { + enumerable, + value: defaults + }, + instances: { + enumerable, + value: instances + }, + overrides: { + enumerable, + value: overrides + }, + registry: { + enumerable, + value: registry + }, + version: { + enumerable, + value: version + }, + getChart: { + enumerable, + value: getChart + }, + register: { + enumerable, + value: (...items) => { + registry.add(...items); + invalidatePlugins(); + } + }, + unregister: { + enumerable, + value: (...items) => { + registry.remove(...items); + invalidatePlugins(); + } + } +}); + +function abstract() { + throw new Error('This method is not implemented: Check that a complete date adapter is provided.'); +} +class DateAdapter { + constructor(options) { + this.options = options || {}; + } + init(chartOptions) {} + formats() { + return abstract(); + } + parse(value, format) { + return abstract(); + } + format(timestamp, format) { + return abstract(); + } + add(timestamp, amount, unit) { + return abstract(); + } + diff(a, b, unit) { + return abstract(); + } + startOf(timestamp, unit, weekday) { + return abstract(); + } + endOf(timestamp, unit) { + return abstract(); + } +} +DateAdapter.override = function(members) { + Object.assign(DateAdapter.prototype, members); +}; +var _adapters = { + _date: DateAdapter +}; + +function getAllScaleValues(scale, type) { + if (!scale._cache.$bar) { + const visibleMetas = scale.getMatchingVisibleMetas(type); + let values = []; + for (let i = 0, ilen = visibleMetas.length; i < ilen; i++) { + values = values.concat(visibleMetas[i].controller.getAllParsedValues(scale)); + } + scale._cache.$bar = _arrayUnique(values.sort((a, b) => a - b)); + } + return scale._cache.$bar; +} +function computeMinSampleSize(meta) { + const scale = meta.iScale; + const values = getAllScaleValues(scale, meta.type); + let min = scale._length; + let i, ilen, curr, prev; + const updateMinAndPrev = () => { + if (curr === 32767 || curr === -32768) { + return; + } + if (defined(prev)) { + min = Math.min(min, Math.abs(curr - prev) || min); + } + prev = curr; + }; + for (i = 0, ilen = values.length; i < ilen; ++i) { + curr = scale.getPixelForValue(values[i]); + updateMinAndPrev(); + } + prev = undefined; + for (i = 0, ilen = scale.ticks.length; i < ilen; ++i) { + curr = scale.getPixelForTick(i); + updateMinAndPrev(); + } + return min; +} +function computeFitCategoryTraits(index, ruler, options, stackCount) { + const thickness = options.barThickness; + let size, ratio; + if (isNullOrUndef(thickness)) { + size = ruler.min * options.categoryPercentage; + ratio = options.barPercentage; + } else { + size = thickness * stackCount; + ratio = 1; + } + return { + chunk: size / stackCount, + ratio, + start: ruler.pixels[index] - (size / 2) + }; +} +function computeFlexCategoryTraits(index, ruler, options, stackCount) { + const pixels = ruler.pixels; + const curr = pixels[index]; + let prev = index > 0 ? pixels[index - 1] : null; + let next = index < pixels.length - 1 ? pixels[index + 1] : null; + const percent = options.categoryPercentage; + if (prev === null) { + prev = curr - (next === null ? ruler.end - ruler.start : next - curr); + } + if (next === null) { + next = curr + curr - prev; + } + const start = curr - (curr - Math.min(prev, next)) / 2 * percent; + const size = Math.abs(next - prev) / 2 * percent; + return { + chunk: size / stackCount, + ratio: options.barPercentage, + start + }; +} +function parseFloatBar(entry, item, vScale, i) { + const startValue = vScale.parse(entry[0], i); + const endValue = vScale.parse(entry[1], i); + const min = Math.min(startValue, endValue); + const max = Math.max(startValue, endValue); + let barStart = min; + let barEnd = max; + if (Math.abs(min) > Math.abs(max)) { + barStart = max; + barEnd = min; + } + item[vScale.axis] = barEnd; + item._custom = { + barStart, + barEnd, + start: startValue, + end: endValue, + min, + max + }; +} +function parseValue(entry, item, vScale, i) { + if (isArray(entry)) { + parseFloatBar(entry, item, vScale, i); + } else { + item[vScale.axis] = vScale.parse(entry, i); + } + return item; +} +function parseArrayOrPrimitive(meta, data, start, count) { + const iScale = meta.iScale; + const vScale = meta.vScale; + const labels = iScale.getLabels(); + const singleScale = iScale === vScale; + const parsed = []; + let i, ilen, item, entry; + for (i = start, ilen = start + count; i < ilen; ++i) { + entry = data[i]; + item = {}; + item[iScale.axis] = singleScale || iScale.parse(labels[i], i); + parsed.push(parseValue(entry, item, vScale, i)); + } + return parsed; +} +function isFloatBar(custom) { + return custom && custom.barStart !== undefined && custom.barEnd !== undefined; +} +function barSign(size, vScale, actualBase) { + if (size !== 0) { + return sign(size); + } + return (vScale.isHorizontal() ? 1 : -1) * (vScale.min >= actualBase ? 1 : -1); +} +function borderProps(properties) { + let reverse, start, end, top, bottom; + if (properties.horizontal) { + reverse = properties.base > properties.x; + start = 'left'; + end = 'right'; + } else { + reverse = properties.base < properties.y; + start = 'bottom'; + end = 'top'; + } + if (reverse) { + top = 'end'; + bottom = 'start'; + } else { + top = 'start'; + bottom = 'end'; + } + return {start, end, reverse, top, bottom}; +} +function setBorderSkipped(properties, options, stack, index) { + let edge = options.borderSkipped; + const res = {}; + if (!edge) { + properties.borderSkipped = res; + return; + } + if (edge === true) { + properties.borderSkipped = {top: true, right: true, bottom: true, left: true}; + return; + } + const {start, end, reverse, top, bottom} = borderProps(properties); + if (edge === 'middle' && stack) { + properties.enableBorderRadius = true; + if ((stack._top || 0) === index) { + edge = top; + } else if ((stack._bottom || 0) === index) { + edge = bottom; + } else { + res[parseEdge(bottom, start, end, reverse)] = true; + edge = top; + } + } + res[parseEdge(edge, start, end, reverse)] = true; + properties.borderSkipped = res; +} +function parseEdge(edge, a, b, reverse) { + if (reverse) { + edge = swap(edge, a, b); + edge = startEnd(edge, b, a); + } else { + edge = startEnd(edge, a, b); + } + return edge; +} +function swap(orig, v1, v2) { + return orig === v1 ? v2 : orig === v2 ? v1 : orig; +} +function startEnd(v, start, end) { + return v === 'start' ? start : v === 'end' ? end : v; +} +function setInflateAmount(properties, {inflateAmount}, ratio) { + properties.inflateAmount = inflateAmount === 'auto' + ? ratio === 1 ? 0.33 : 0 + : inflateAmount; +} +class BarController extends DatasetController { + parsePrimitiveData(meta, data, start, count) { + return parseArrayOrPrimitive(meta, data, start, count); + } + parseArrayData(meta, data, start, count) { + return parseArrayOrPrimitive(meta, data, start, count); + } + parseObjectData(meta, data, start, count) { + const {iScale, vScale} = meta; + const {xAxisKey = 'x', yAxisKey = 'y'} = this._parsing; + const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey; + const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey; const parsed = []; - let i, ilen, item, entry; + let i, ilen, item, obj; for (i = start, ilen = start + count; i < ilen; ++i) { - entry = data[i]; + obj = data[i]; item = {}; - item[iScale.axis] = singleScale || iScale.parse(labels[i], i); - parsed.push(parseValue(entry, item, vScale, i)); + item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i); + parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i)); } return parsed; } - function isFloatBar(custom) { - return custom && custom.barStart !== undefined && custom.barEnd !== undefined; - } - const BarController = function (_DatasetController) { - _inheritsLoose(BarController, _DatasetController); - function BarController() { - return _DatasetController.apply(this, arguments) || this; - } - const _proto = BarController.prototype; - _proto.parsePrimitiveData = function parsePrimitiveData(meta, data, start, count) { - return parseArrayOrPrimitive(meta, data, start, count); - } - ; - _proto.parseArrayData = function parseArrayData(meta, data, start, count) { - return parseArrayOrPrimitive(meta, data, start, count); - } - ; - _proto.parseObjectData = function parseObjectData(meta, data, start, count) { - const iScale = meta.iScale, - vScale = meta.vScale; - const _this$_parsing = this._parsing, - _this$_parsing$xAxisK = _this$_parsing.xAxisKey, - xAxisKey = _this$_parsing$xAxisK === void 0 ? 'x' : _this$_parsing$xAxisK, - _this$_parsing$yAxisK = _this$_parsing.yAxisKey, - yAxisKey = _this$_parsing$yAxisK === void 0 ? 'y' : _this$_parsing$yAxisK; - const iAxisKey = iScale.axis === 'x' ? xAxisKey : yAxisKey; - const vAxisKey = vScale.axis === 'x' ? xAxisKey : yAxisKey; - const parsed = []; - let i, ilen, item, obj; - for (i = start, ilen = start + count; i < ilen; ++i) { - obj = data[i]; - item = {}; - item[iScale.axis] = iScale.parse(resolveObjectKey(obj, iAxisKey), i); - parsed.push(parseValue(resolveObjectKey(obj, vAxisKey), item, vScale, i)); - } - return parsed; - } - ; - _proto.updateRangeFromParsed = function updateRangeFromParsed(range, scale, parsed, stack) { - _DatasetController.prototype.updateRangeFromParsed.call(this, range, scale, parsed, stack); - const custom = parsed._custom; - if (custom && scale === this._cachedMeta.vScale) { - range.min = Math.min(range.min, custom.min); - range.max = Math.max(range.max, custom.max); - } - } - ; - _proto.getLabelAndValue = function getLabelAndValue(index) { - const me = this; - const meta = me._cachedMeta; - const iScale = meta.iScale, - vScale = meta.vScale; - const parsed = me.getParsed(index); - const custom = parsed._custom; - const value = isFloatBar(custom) ? '[' + custom.start + ', ' + custom.end + ']' : '' + vScale.getLabelForValue(parsed[vScale.axis]); - return { - label: '' + iScale.getLabelForValue(parsed[iScale.axis]), - value: value + updateRangeFromParsed(range, scale, parsed, stack) { + super.updateRangeFromParsed(range, scale, parsed, stack); + const custom = parsed._custom; + if (custom && scale === this._cachedMeta.vScale) { + range.min = Math.min(range.min, custom.min); + range.max = Math.max(range.max, custom.max); + } + } + getMaxOverflow() { + return 0; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const {iScale, vScale} = meta; + const parsed = this.getParsed(index); + const custom = parsed._custom; + const value = isFloatBar(custom) + ? '[' + custom.start + ', ' + custom.end + ']' + : '' + vScale.getLabelForValue(parsed[vScale.axis]); + return { + label: '' + iScale.getLabelForValue(parsed[iScale.axis]), + value + }; + } + initialize() { + this.enableOptionSharing = true; + super.initialize(); + const meta = this._cachedMeta; + meta.stack = this.getDataset().stack; + } + update(mode) { + const meta = this._cachedMeta; + this.updateElements(meta.data, 0, meta.data.length, mode); + } + updateElements(bars, start, count, mode) { + const reset = mode === 'reset'; + const {index, _cachedMeta: {vScale}} = this; + const base = vScale.getBasePixel(); + const horizontal = vScale.isHorizontal(); + const ruler = this._getRuler(); + const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode); + for (let i = start; i < start + count; i++) { + const parsed = this.getParsed(i); + const vpixels = reset || isNullOrUndef(parsed[vScale.axis]) ? {base, head: base} : this._calculateBarValuePixels(i); + const ipixels = this._calculateBarIndexPixels(i, ruler); + const stack = (parsed._stacks || {})[vScale.axis]; + const properties = { + horizontal, + base: vpixels.base, + enableBorderRadius: !stack || isFloatBar(parsed._custom) || (index === stack._top || index === stack._bottom), + x: horizontal ? vpixels.head : ipixels.center, + y: horizontal ? ipixels.center : vpixels.head, + height: horizontal ? ipixels.size : Math.abs(vpixels.size), + width: horizontal ? Math.abs(vpixels.size) : ipixels.size }; + if (includeOptions) { + properties.options = sharedOptions || this.resolveDataElementOptions(i, bars[i].active ? 'active' : mode); + } + const options = properties.options || bars[i].options; + setBorderSkipped(properties, options, stack, index); + setInflateAmount(properties, options, ruler.ratio); + this.updateElement(bars[i], i, properties, mode); + } + } + _getStacks(last, dataIndex) { + const {iScale} = this._cachedMeta; + const metasets = iScale.getMatchingVisibleMetas(this._type) + .filter(meta => meta.controller.options.grouped); + const stacked = iScale.options.stacked; + const stacks = []; + const skipNull = (meta) => { + const parsed = meta.controller.getParsed(dataIndex); + const val = parsed && parsed[meta.vScale.axis]; + if (isNullOrUndef(val) || isNaN(val)) { + return true; + } }; - _proto.initialize = function initialize() { - const me = this; - me.enableOptionSharing = true; - _DatasetController.prototype.initialize.call(this); - const meta = me._cachedMeta; - meta.stack = me.getDataset().stack; - }; - _proto.update = function update(mode) { - const me = this; - const meta = me._cachedMeta; - me.updateElements(meta.data, 0, meta.data.length, mode); - }; - _proto.updateElements = function updateElements(bars, start, count, mode) { - const me = this; - const reset = mode === 'reset'; - const vscale = me._cachedMeta.vScale; - const base = vscale.getBasePixel(); - const horizontal = vscale.isHorizontal(); - const ruler = me._getRuler(); - const firstOpts = me.resolveDataElementOptions(start, mode); - const sharedOptions = me.getSharedOptions(firstOpts); - const includeOptions = me.includeOptions(mode, sharedOptions); - me.updateSharedOptions(sharedOptions, mode, firstOpts); - for (let i = start; i < start + count; i++) { - const options = sharedOptions || me.resolveDataElementOptions(i, mode); - const vpixels = me._calculateBarValuePixels(i, options); - const ipixels = me._calculateBarIndexPixels(i, ruler, options); - const properties = { - horizontal: horizontal, - base: reset ? base : vpixels.base, - x: horizontal ? reset ? base : vpixels.head : ipixels.center, - y: horizontal ? ipixels.center : reset ? base : vpixels.head, - height: horizontal ? ipixels.size : undefined, - width: horizontal ? undefined : ipixels.size - }; - if (includeOptions) { - properties.options = options; - } - me.updateElement(bars[i], i, properties, mode); - } - } - ; - _proto._getStacks = function _getStacks(last, dataIndex) { - const me = this; - const meta = me._cachedMeta; - const iScale = meta.iScale; - const metasets = iScale.getMatchingVisibleMetas(me._type); - const stacked = iScale.options.stacked; - const ilen = metasets.length; - const stacks = []; - let i, item; - for (i = 0; i < ilen; ++i) { - item = metasets[i]; - if (typeof dataIndex !== 'undefined') { - const val = item.controller.getParsed(dataIndex)[item.controller._cachedMeta.vScale.axis]; - if (isNullOrUndef(val) || isNaN(val)) { - continue; - } - } - if (stacked === false || stacks.indexOf(item.stack) === -1 || stacked === undefined && item.stack === undefined) { - stacks.push(item.stack); - } - if (item.index === last) { - break; - } + for (const meta of metasets) { + if (dataIndex !== undefined && skipNull(meta)) { + continue; + } + if (stacked === false || stacks.indexOf(meta.stack) === -1 || + (stacked === undefined && meta.stack === undefined)) { + stacks.push(meta.stack); } - if (!stacks.length) { - stacks.push(undefined); + if (meta.index === last) { + break; } - return stacks; } - ; - _proto._getStackCount = function _getStackCount(index) { - return this._getStacks(undefined, index).length; + if (!stacks.length) { + stacks.push(undefined); } - ; - _proto._getStackIndex = function _getStackIndex(datasetIndex, name) { - const stacks = this._getStacks(datasetIndex); - const index = name !== undefined ? stacks.indexOf(name) : -1; - return index === -1 ? stacks.length - 1 : index; + return stacks; + } + _getStackCount(index) { + return this._getStacks(undefined, index).length; + } + _getStackIndex(datasetIndex, name, dataIndex) { + const stacks = this._getStacks(datasetIndex, dataIndex); + const index = (name !== undefined) + ? stacks.indexOf(name) + : -1; + return (index === -1) + ? stacks.length - 1 + : index; + } + _getRuler() { + const opts = this.options; + const meta = this._cachedMeta; + const iScale = meta.iScale; + const pixels = []; + let i, ilen; + for (i = 0, ilen = meta.data.length; i < ilen; ++i) { + pixels.push(iScale.getPixelForValue(this.getParsed(i)[iScale.axis], i)); } - ; - _proto._getRuler = function _getRuler() { - const me = this; - const meta = me._cachedMeta; - const iScale = meta.iScale; - const pixels = []; - let i, ilen; - for (i = 0, ilen = meta.data.length; i < ilen; ++i) { - pixels.push(iScale.getPixelForValue(me.getParsed(i)[iScale.axis], i)); + const barThickness = opts.barThickness; + const min = barThickness || computeMinSampleSize(meta); + return { + min, + pixels, + start: iScale._startPixel, + end: iScale._endPixel, + stackCount: this._getStackCount(), + scale: iScale, + grouped: opts.grouped, + ratio: barThickness ? 1 : opts.categoryPercentage * opts.barPercentage + }; + } + _calculateBarValuePixels(index) { + const {_cachedMeta: {vScale, _stacked}, options: {base: baseValue, minBarLength}} = this; + const actualBase = baseValue || 0; + const parsed = this.getParsed(index); + const custom = parsed._custom; + const floating = isFloatBar(custom); + let value = parsed[vScale.axis]; + let start = 0; + let length = _stacked ? this.applyStack(vScale, parsed, _stacked) : value; + let head, size; + if (length !== value) { + start = length - value; + length = value; + } + if (floating) { + value = custom.barStart; + length = custom.barEnd - custom.barStart; + if (value !== 0 && sign(value) !== sign(custom.barEnd)) { + start = 0; } - const min = computeMinSampleSize(iScale); - return { - min: min, - pixels: pixels, - start: iScale._startPixel, - end: iScale._endPixel, - stackCount: me._getStackCount(), - scale: iScale - }; + start += value; } - ; - _proto._calculateBarValuePixels = function _calculateBarValuePixels(index, options) { - const me = this; - const meta = me._cachedMeta; - const vScale = meta.vScale; - const baseValue = options.base, - minBarLength = options.minBarLength; - const parsed = me.getParsed(index); - const custom = parsed._custom; - const floating = isFloatBar(custom); - let value = parsed[vScale.axis]; - let start = 0; - let length = meta._stacked ? me.applyStack(vScale, parsed) : value; - let head, size; - if (length !== value) { - start = length - value; - length = value; - } - if (floating) { - value = custom.barStart; - length = custom.barEnd - custom.barStart; - if (value !== 0 && sign(value) !== sign(custom.barEnd)) { - start = 0; - } - start += value; - } - const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start; - let base = vScale.getPixelForValue(startValue); - if (this.chart.getDataVisibility(index)) { - head = vScale.getPixelForValue(start + length); - } else { - head = base; - } - size = head - base; - if (minBarLength !== undefined && Math.abs(size) < minBarLength) { - size = size < 0 ? -minBarLength : minBarLength; - if (value === 0) { - base -= size / 2; - } - head = base + size; - } - return { - size: size, - base: base, - head: head, - center: head + size / 2 - }; + const startValue = !isNullOrUndef(baseValue) && !floating ? baseValue : start; + let base = vScale.getPixelForValue(startValue); + if (this.chart.getDataVisibility(index)) { + head = vScale.getPixelForValue(start + length); + } else { + head = base; + } + size = head - base; + if (Math.abs(size) < minBarLength) { + size = barSign(size, vScale, actualBase) * minBarLength; + if (value === actualBase) { + base -= size / 2; + } + const startPixel = vScale.getPixelForDecimal(0); + const endPixel = vScale.getPixelForDecimal(1); + const min = Math.min(startPixel, endPixel); + const max = Math.max(startPixel, endPixel); + base = Math.max(Math.min(base, max), min); + head = base + size; + } + if (base === vScale.getPixelForValue(actualBase)) { + const halfGrid = sign(size) * vScale.getLineWidthForValue(actualBase) / 2; + base += halfGrid; + size -= halfGrid; } - ; - _proto._calculateBarIndexPixels = function _calculateBarIndexPixels(index, ruler, options) { - const me = this; - const stackCount = me.chart.options.skipNull ? me._getStackCount(index) : ruler.stackCount; - const range = options.barThickness === 'flex' ? computeFlexCategoryTraits(index, ruler, options, stackCount) : computeFitCategoryTraits(index, ruler, options, stackCount); - const stackIndex = me._getStackIndex(me.index, me._cachedMeta.stack); - const center = range.start + range.chunk * stackIndex + range.chunk / 2; - const size = Math.min(valueOrDefault(options.maxBarThickness, Infinity), range.chunk * range.ratio); - return { - base: center - size / 2, - head: center + size / 2, - center: center, - size: size - }; + return { + size, + base, + head, + center: head + size / 2 + }; + } + _calculateBarIndexPixels(index, ruler) { + const scale = ruler.scale; + const options = this.options; + const skipNull = options.skipNull; + const maxBarThickness = valueOrDefault(options.maxBarThickness, Infinity); + let center, size; + if (ruler.grouped) { + const stackCount = skipNull ? this._getStackCount(index) : ruler.stackCount; + const range = options.barThickness === 'flex' + ? computeFlexCategoryTraits(index, ruler, options, stackCount) + : computeFitCategoryTraits(index, ruler, options, stackCount); + const stackIndex = this._getStackIndex(this.index, this._cachedMeta.stack, skipNull ? index : undefined); + center = range.start + (range.chunk * stackIndex) + (range.chunk / 2); + size = Math.min(maxBarThickness, range.chunk * range.ratio); + } else { + center = scale.getPixelForValue(this.getParsed(index)[scale.axis], index); + size = Math.min(maxBarThickness, ruler.min * ruler.ratio); + } + return { + base: center - size / 2, + head: center + size / 2, + center, + size }; - _proto.draw = function draw() { - const me = this; - const chart = me.chart; - const meta = me._cachedMeta; - const vScale = meta.vScale; - const rects = meta.data; - const ilen = rects.length; - let i = 0; - clipArea(chart.ctx, chart.chartArea); - for (; i < ilen; ++i) { - if (!isNaN(me.getParsed(i)[vScale.axis])) { - rects[i].draw(me._ctx); - } + } + draw() { + const meta = this._cachedMeta; + const vScale = meta.vScale; + const rects = meta.data; + const ilen = rects.length; + let i = 0; + for (; i < ilen; ++i) { + if (this.getParsed(i)[vScale.axis] !== null) { + rects[i].draw(this._ctx); } - unclipArea(chart.ctx); - }; - return BarController; - }(DatasetController); - BarController.id = 'bar'; - BarController.defaults = { - datasetElementType: false, - dataElementType: 'bar', - dataElementOptions: ['backgroundColor', 'borderColor', 'borderSkipped', 'borderWidth', 'borderRadius', 'barPercentage', 'barThickness', 'base', 'categoryPercentage', 'maxBarThickness', 'minBarLength'], - interaction: { - mode: 'index' - }, - hover: {}, - datasets: { - categoryPercentage: 0.8, - barPercentage: 0.9, - animation: { - numbers: { - type: 'number', - properties: ['x', 'y', 'base', 'width', 'height'] - } + } + } +} +BarController.id = 'bar'; +BarController.defaults = { + datasetElementType: false, + dataElementType: 'bar', + categoryPercentage: 0.8, + barPercentage: 0.9, + grouped: true, + animations: { + numbers: { + type: 'number', + properties: ['x', 'y', 'base', 'width', 'height'] + } + } +}; +BarController.overrides = { + scales: { + _index_: { + type: 'category', + offset: true, + grid: { + offset: true } }, - scales: { - _index_: { - type: 'category', - offset: true, - gridLines: { - offsetGridLines: true - } - }, - _value_: { - type: 'linear', - beginAtZero: true - } + _value_: { + type: 'linear', + beginAtZero: true, } - }; + } +}; - const BubbleController = function (_DatasetController) { - _inheritsLoose(BubbleController, _DatasetController); - function BubbleController() { - return _DatasetController.apply(this, arguments) || this; - } - const _proto = BubbleController.prototype; - _proto.initialize = function initialize() { - this.enableOptionSharing = true; - _DatasetController.prototype.initialize.call(this); - } - ; - _proto.parseObjectData = function parseObjectData(meta, data, start, count) { - const xScale = meta.xScale, - yScale = meta.yScale; - const _this$_parsing = this._parsing, - _this$_parsing$xAxisK = _this$_parsing.xAxisKey, - xAxisKey = _this$_parsing$xAxisK === void 0 ? 'x' : _this$_parsing$xAxisK, - _this$_parsing$yAxisK = _this$_parsing.yAxisKey, - yAxisKey = _this$_parsing$yAxisK === void 0 ? 'y' : _this$_parsing$yAxisK; - const parsed = []; - let i, ilen, item; - for (i = start, ilen = start + count; i < ilen; ++i) { - item = data[i]; - parsed.push({ - x: xScale.parse(resolveObjectKey(item, xAxisKey), i), - y: yScale.parse(resolveObjectKey(item, yAxisKey), i), - _custom: item && item.r && +item.r - }); - } - return parsed; +class BubbleController extends DatasetController { + initialize() { + this.enableOptionSharing = true; + super.initialize(); + } + parsePrimitiveData(meta, data, start, count) { + const parsed = super.parsePrimitiveData(meta, data, start, count); + for (let i = 0; i < parsed.length; i++) { + parsed[i]._custom = this.resolveDataElementOptions(i + start).radius; } - ; - _proto.getMaxOverflow = function getMaxOverflow() { - const me = this; - const meta = me._cachedMeta; - const data = meta.data; - let max = 0; - for (let i = data.length - 1; i >= 0; --i) { - max = Math.max(max, data[i].size()); - } - return max > 0 && max; + return parsed; + } + parseArrayData(meta, data, start, count) { + const parsed = super.parseArrayData(meta, data, start, count); + for (let i = 0; i < parsed.length; i++) { + const item = data[start + i]; + parsed[i]._custom = valueOrDefault(item[2], this.resolveDataElementOptions(i + start).radius); } - ; - _proto.getLabelAndValue = function getLabelAndValue(index) { - const me = this; - const meta = me._cachedMeta; - const xScale = meta.xScale, - yScale = meta.yScale; - const parsed = me.getParsed(index); - const x = xScale.getLabelForValue(parsed.x); - const y = yScale.getLabelForValue(parsed.y); - const r = parsed._custom; - return { - label: meta.label, - value: '(' + x + ', ' + y + (r ? ', ' + r : '') + ')' - }; - }; - _proto.update = function update(mode) { - const me = this; - const points = me._cachedMeta.data; - me.updateElements(points, 0, points.length, mode); - }; - _proto.updateElements = function updateElements(points, start, count, mode) { - const me = this; - const reset = mode === 'reset'; - const _me$_cachedMeta = me._cachedMeta, - xScale = _me$_cachedMeta.xScale, - yScale = _me$_cachedMeta.yScale; - const firstOpts = me.resolveDataElementOptions(start, mode); - const sharedOptions = me.getSharedOptions(firstOpts); - const includeOptions = me.includeOptions(mode, sharedOptions); - for (let i = start; i < start + count; i++) { - const point = points[i]; - const parsed = !reset && me.getParsed(i); - const x = reset ? xScale.getPixelForDecimal(0.5) : xScale.getPixelForValue(parsed.x); - const y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(parsed.y); - const properties = { - x: x, - y: y, - skip: isNaN(x) || isNaN(y) - }; - if (includeOptions) { - properties.options = me.resolveDataElementOptions(i, mode); - if (reset) { - properties.options.radius = 0; - } - } - me.updateElement(point, i, properties, mode); - } - me.updateSharedOptions(sharedOptions, mode, firstOpts); - } - ; - _proto.resolveDataElementOptions = function resolveDataElementOptions(index, mode) { - const me = this; - const chart = me.chart; - const parsed = me.getParsed(index); - let values = _DatasetController.prototype.resolveDataElementOptions.call(this, index, mode); - const context = me.getContext(index, mode === 'active'); - if (values.$shared) { - values = _extends({}, values, { - $shared: false - }); - } - if (mode !== 'active') { - values.radius = 0; - } - values.radius += resolve([parsed && parsed._custom, me._config.radius, chart.options.elements.point.radius], context, index); - return values; + return parsed; + } + parseObjectData(meta, data, start, count) { + const parsed = super.parseObjectData(meta, data, start, count); + for (let i = 0; i < parsed.length; i++) { + const item = data[start + i]; + parsed[i]._custom = valueOrDefault(item && item.r && +item.r, this.resolveDataElementOptions(i + start).radius); + } + return parsed; + } + getMaxOverflow() { + const data = this._cachedMeta.data; + let max = 0; + for (let i = data.length - 1; i >= 0; --i) { + max = Math.max(max, data[i].size(this.resolveDataElementOptions(i)) / 2); + } + return max > 0 && max; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const {xScale, yScale} = meta; + const parsed = this.getParsed(index); + const x = xScale.getLabelForValue(parsed.x); + const y = yScale.getLabelForValue(parsed.y); + const r = parsed._custom; + return { + label: meta.label, + value: '(' + x + ', ' + y + (r ? ', ' + r : '') + ')' }; - return BubbleController; - }(DatasetController); - BubbleController.id = 'bubble'; - BubbleController.defaults = { - datasetElementType: false, - dataElementType: 'point', - dataElementOptions: ['backgroundColor', 'borderColor', 'borderWidth', 'hitRadius', 'radius', 'pointStyle', 'rotation'], - animation: { - numbers: { - properties: ['x', 'y', 'borderWidth', 'radius'] - } - }, - scales: { - x: { - type: 'linear' - }, - y: { - type: 'linear' - } - }, - tooltips: { - callbacks: { - title: function title() { - return ''; + } + update(mode) { + const points = this._cachedMeta.data; + this.updateElements(points, 0, points.length, mode); + } + updateElements(points, start, count, mode) { + const reset = mode === 'reset'; + const {iScale, vScale} = this._cachedMeta; + const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode); + const iAxis = iScale.axis; + const vAxis = vScale.axis; + for (let i = start; i < start + count; i++) { + const point = points[i]; + const parsed = !reset && this.getParsed(i); + const properties = {}; + const iPixel = properties[iAxis] = reset ? iScale.getPixelForDecimal(0.5) : iScale.getPixelForValue(parsed[iAxis]); + const vPixel = properties[vAxis] = reset ? vScale.getBasePixel() : vScale.getPixelForValue(parsed[vAxis]); + properties.skip = isNaN(iPixel) || isNaN(vPixel); + if (includeOptions) { + properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode); + if (reset) { + properties.options.radius = 0; } } + this.updateElement(point, i, properties, mode); } - }; - - function getRatioAndOffset(rotation, circumference, cutout) { - let ratioX = 1; - let ratioY = 1; - let offsetX = 0; - let offsetY = 0; - if (circumference < TAU) { - let startAngle = rotation % TAU; - startAngle += startAngle >= PI ? -TAU : startAngle < -PI ? TAU : 0; - const endAngle = startAngle + circumference; - const startX = Math.cos(startAngle); - const startY = Math.sin(startAngle); - const endX = Math.cos(endAngle); - const endY = Math.sin(endAngle); - const contains0 = startAngle <= 0 && endAngle >= 0 || endAngle >= TAU; - const contains90 = startAngle <= HALF_PI && endAngle >= HALF_PI || endAngle >= TAU + HALF_PI; - const contains180 = startAngle === -PI || endAngle >= PI; - const contains270 = startAngle <= -HALF_PI && endAngle >= -HALF_PI || endAngle >= PI + HALF_PI; - const minX = contains180 ? -1 : Math.min(startX, startX * cutout, endX, endX * cutout); - const minY = contains270 ? -1 : Math.min(startY, startY * cutout, endY, endY * cutout); - const maxX = contains0 ? 1 : Math.max(startX, startX * cutout, endX, endX * cutout); - const maxY = contains90 ? 1 : Math.max(startY, startY * cutout, endY, endY * cutout); - ratioX = (maxX - minX) / 2; - ratioY = (maxY - minY) / 2; - offsetX = -(maxX + minX) / 2; - offsetY = -(maxY + minY) / 2; + } + resolveDataElementOptions(index, mode) { + const parsed = this.getParsed(index); + let values = super.resolveDataElementOptions(index, mode); + if (values.$shared) { + values = Object.assign({}, values, {$shared: false}); } - return { - ratioX: ratioX, - ratioY: ratioY, - offsetX: offsetX, - offsetY: offsetY - }; + const radius = values.radius; + if (mode !== 'active') { + values.radius = 0; + } + values.radius += valueOrDefault(parsed && parsed._custom, radius); + return values; } - const DoughnutController = function (_DatasetController) { - _inheritsLoose(DoughnutController, _DatasetController); - function DoughnutController(chart, datasetIndex) { - let _this; - _this = _DatasetController.call(this, chart, datasetIndex) || this; - _this.enableOptionSharing = true; - _this.innerRadius = undefined; - _this.outerRadius = undefined; - _this.offsetX = undefined; - _this.offsetY = undefined; - return _this; - } - const _proto = DoughnutController.prototype; - _proto.linkScales = function linkScales() {} - ; - _proto.parse = function parse(start, count) { - const data = this.getDataset().data; - const meta = this._cachedMeta; - let i, ilen; - for (i = start, ilen = start + count; i < ilen; ++i) { - meta._parsed[i] = +data[i]; - } +} +BubbleController.id = 'bubble'; +BubbleController.defaults = { + datasetElementType: false, + dataElementType: 'point', + animations: { + numbers: { + type: 'number', + properties: ['x', 'y', 'borderWidth', 'radius'] } - ; - _proto.getRingIndex = function getRingIndex(datasetIndex) { - let ringIndex = 0; - for (let j = 0; j < datasetIndex; ++j) { - if (this.chart.isDatasetVisible(j)) { - ++ringIndex; - } - } - return ringIndex; - } - ; - _proto._getRotation = function _getRotation() { - return toRadians(valueOrDefault(this._config.rotation, this.chart.options.rotation) - 90); - } - ; - _proto._getCircumference = function _getCircumference() { - return toRadians(valueOrDefault(this._config.circumference, this.chart.options.circumference)); - } - ; - _proto._getRotationExtents = function _getRotationExtents() { - let min = TAU; - let max = -TAU; - const me = this; - for (let i = 0; i < me.chart.data.datasets.length; ++i) { - if (me.chart.isDatasetVisible(i)) { - const controller = me.chart.getDatasetMeta(i).controller; - const rotation = controller._getRotation(); - const circumference = controller._getCircumference(); - min = Math.min(min, rotation); - max = Math.max(max, rotation + circumference); + } +}; +BubbleController.overrides = { + scales: { + x: { + type: 'linear' + }, + y: { + type: 'linear' + } + }, + plugins: { + tooltip: { + callbacks: { + title() { + return ''; } } - return { - rotation: min, - circumference: max - min - }; } - ; - _proto.update = function update(mode) { - const me = this; - const chart = me.chart; - const chartArea = chart.chartArea, - options = chart.options; - const meta = me._cachedMeta; - const arcs = meta.data; - const cutout = options.cutoutPercentage / 100 || 0; - const chartWeight = me._getRingWeight(me.index); - const _me$_getRotationExten = me._getRotationExtents(), - circumference = _me$_getRotationExten.circumference, - rotation = _me$_getRotationExten.rotation; - const _getRatioAndOffset = getRatioAndOffset(rotation, circumference, cutout), - ratioX = _getRatioAndOffset.ratioX, - ratioY = _getRatioAndOffset.ratioY, - offsetX = _getRatioAndOffset.offsetX, - offsetY = _getRatioAndOffset.offsetY; - const spacing = me.getMaxBorderWidth() + me.getMaxOffset(arcs); - const maxWidth = (chartArea.right - chartArea.left - spacing) / ratioX; - const maxHeight = (chartArea.bottom - chartArea.top - spacing) / ratioY; - const outerRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0); - const innerRadius = Math.max(outerRadius * cutout, 0); - const radiusLength = (outerRadius - innerRadius) / me._getVisibleDatasetWeightTotal(); - me.offsetX = offsetX * outerRadius; - me.offsetY = offsetY * outerRadius; - meta.total = me.calculateTotal(); - me.outerRadius = outerRadius - radiusLength * me._getRingWeightOffset(me.index); - me.innerRadius = Math.max(me.outerRadius - radiusLength * chartWeight, 0); - me.updateElements(arcs, 0, arcs.length, mode); - } - ; - _proto._circumference = function _circumference(i, reset) { - const me = this; - const opts = me.chart.options; - const meta = me._cachedMeta; - const circumference = me._getCircumference(); - return reset && opts.animation.animateRotate ? 0 : this.chart.getDataVisibility(i) ? me.calculateCircumference(meta._parsed[i] * circumference / TAU) : 0; - }; - _proto.updateElements = function updateElements(arcs, start, count, mode) { - const me = this; - const reset = mode === 'reset'; - const chart = me.chart; - const chartArea = chart.chartArea; - const opts = chart.options; - const animationOpts = opts.animation; - const centerX = (chartArea.left + chartArea.right) / 2; - const centerY = (chartArea.top + chartArea.bottom) / 2; - const animateScale = reset && animationOpts.animateScale; - const innerRadius = animateScale ? 0 : me.innerRadius; - const outerRadius = animateScale ? 0 : me.outerRadius; - const firstOpts = me.resolveDataElementOptions(start, mode); - const sharedOptions = me.getSharedOptions(firstOpts); - const includeOptions = me.includeOptions(mode, sharedOptions); - let startAngle = me._getRotation(); - let i; - for (i = 0; i < start; ++i) { - startAngle += me._circumference(i, reset); - } - for (i = start; i < start + count; ++i) { - const circumference = me._circumference(i, reset); - const arc = arcs[i]; - const properties = { - x: centerX + me.offsetX, - y: centerY + me.offsetY, - startAngle: startAngle, - endAngle: startAngle + circumference, - circumference: circumference, - outerRadius: outerRadius, - innerRadius: innerRadius - }; - if (includeOptions) { - properties.options = sharedOptions || me.resolveDataElementOptions(i, mode); - } - startAngle += circumference; - me.updateElement(arc, i, properties, mode); + } +}; + +function getRatioAndOffset(rotation, circumference, cutout) { + let ratioX = 1; + let ratioY = 1; + let offsetX = 0; + let offsetY = 0; + if (circumference < TAU) { + const startAngle = rotation; + const endAngle = startAngle + circumference; + const startX = Math.cos(startAngle); + const startY = Math.sin(startAngle); + const endX = Math.cos(endAngle); + const endY = Math.sin(endAngle); + const calcMax = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? 1 : Math.max(a, a * cutout, b, b * cutout); + const calcMin = (angle, a, b) => _angleBetween(angle, startAngle, endAngle, true) ? -1 : Math.min(a, a * cutout, b, b * cutout); + const maxX = calcMax(0, startX, endX); + const maxY = calcMax(HALF_PI, startY, endY); + const minX = calcMin(PI, startX, endX); + const minY = calcMin(PI + HALF_PI, startY, endY); + ratioX = (maxX - minX) / 2; + ratioY = (maxY - minY) / 2; + offsetX = -(maxX + minX) / 2; + offsetY = -(maxY + minY) / 2; + } + return {ratioX, ratioY, offsetX, offsetY}; +} +class DoughnutController extends DatasetController { + constructor(chart, datasetIndex) { + super(chart, datasetIndex); + this.enableOptionSharing = true; + this.innerRadius = undefined; + this.outerRadius = undefined; + this.offsetX = undefined; + this.offsetY = undefined; + } + linkScales() {} + parse(start, count) { + const data = this.getDataset().data; + const meta = this._cachedMeta; + if (this._parsing === false) { + meta._parsed = data; + } else { + let getter = (i) => +data[i]; + if (isObject(data[start])) { + const {key = 'value'} = this._parsing; + getter = (i) => +resolveObjectKey(data[i], key); } - me.updateSharedOptions(sharedOptions, mode, firstOpts); - }; - _proto.calculateTotal = function calculateTotal() { - const meta = this._cachedMeta; - const metaData = meta.data; - let total = 0; - let i; - for (i = 0; i < metaData.length; i++) { - const value = meta._parsed[i]; - if (!isNaN(value) && this.chart.getDataVisibility(i)) { - total += Math.abs(value); - } + let i, ilen; + for (i = start, ilen = start + count; i < ilen; ++i) { + meta._parsed[i] = getter(i); } - return total; - }; - _proto.calculateCircumference = function calculateCircumference(value) { - const total = this._cachedMeta.total; - if (total > 0 && !isNaN(value)) { - return TAU * (Math.abs(value) / total); + } + } + _getRotation() { + return toRadians(this.options.rotation - 90); + } + _getCircumference() { + return toRadians(this.options.circumference); + } + _getRotationExtents() { + let min = TAU; + let max = -TAU; + for (let i = 0; i < this.chart.data.datasets.length; ++i) { + if (this.chart.isDatasetVisible(i)) { + const controller = this.chart.getDatasetMeta(i).controller; + const rotation = controller._getRotation(); + const circumference = controller._getCircumference(); + min = Math.min(min, rotation); + max = Math.max(max, rotation + circumference); } + } + return { + rotation: min, + circumference: max - min, + }; + } + update(mode) { + const chart = this.chart; + const {chartArea} = chart; + const meta = this._cachedMeta; + const arcs = meta.data; + const spacing = this.getMaxBorderWidth() + this.getMaxOffset(arcs) + this.options.spacing; + const maxSize = Math.max((Math.min(chartArea.width, chartArea.height) - spacing) / 2, 0); + const cutout = Math.min(toPercentage(this.options.cutout, maxSize), 1); + const chartWeight = this._getRingWeight(this.index); + const {circumference, rotation} = this._getRotationExtents(); + const {ratioX, ratioY, offsetX, offsetY} = getRatioAndOffset(rotation, circumference, cutout); + const maxWidth = (chartArea.width - spacing) / ratioX; + const maxHeight = (chartArea.height - spacing) / ratioY; + const maxRadius = Math.max(Math.min(maxWidth, maxHeight) / 2, 0); + const outerRadius = toDimension(this.options.radius, maxRadius); + const innerRadius = Math.max(outerRadius * cutout, 0); + const radiusLength = (outerRadius - innerRadius) / this._getVisibleDatasetWeightTotal(); + this.offsetX = offsetX * outerRadius; + this.offsetY = offsetY * outerRadius; + meta.total = this.calculateTotal(); + this.outerRadius = outerRadius - radiusLength * this._getRingWeightOffset(this.index); + this.innerRadius = Math.max(this.outerRadius - radiusLength * chartWeight, 0); + this.updateElements(arcs, 0, arcs.length, mode); + } + _circumference(i, reset) { + const opts = this.options; + const meta = this._cachedMeta; + const circumference = this._getCircumference(); + if ((reset && opts.animation.animateRotate) || !this.chart.getDataVisibility(i) || meta._parsed[i] === null || meta.data[i].hidden) { return 0; - }; - _proto.getLabelAndValue = function getLabelAndValue(index) { - const me = this; - const meta = me._cachedMeta; - const chart = me.chart; - const labels = chart.data.labels || []; - return { - label: labels[index] || '', - value: meta._parsed[index] + } + return this.calculateCircumference(meta._parsed[i] * circumference / TAU); + } + updateElements(arcs, start, count, mode) { + const reset = mode === 'reset'; + const chart = this.chart; + const chartArea = chart.chartArea; + const opts = chart.options; + const animationOpts = opts.animation; + const centerX = (chartArea.left + chartArea.right) / 2; + const centerY = (chartArea.top + chartArea.bottom) / 2; + const animateScale = reset && animationOpts.animateScale; + const innerRadius = animateScale ? 0 : this.innerRadius; + const outerRadius = animateScale ? 0 : this.outerRadius; + const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode); + let startAngle = this._getRotation(); + let i; + for (i = 0; i < start; ++i) { + startAngle += this._circumference(i, reset); + } + for (i = start; i < start + count; ++i) { + const circumference = this._circumference(i, reset); + const arc = arcs[i]; + const properties = { + x: centerX + this.offsetX, + y: centerY + this.offsetY, + startAngle, + endAngle: startAngle + circumference, + circumference, + outerRadius, + innerRadius }; - }; - _proto.getMaxBorderWidth = function getMaxBorderWidth(arcs) { - const me = this; - let max = 0; - const chart = me.chart; - let i, ilen, meta, controller, options; - if (!arcs) { - for (i = 0, ilen = chart.data.datasets.length; i < ilen; ++i) { - if (chart.isDatasetVisible(i)) { - meta = chart.getDatasetMeta(i); - arcs = meta.data; - controller = meta.controller; - if (controller !== me) { - controller.configure(); - } - break; - } - } + if (includeOptions) { + properties.options = sharedOptions || this.resolveDataElementOptions(i, arc.active ? 'active' : mode); } - if (!arcs) { - return 0; + startAngle += circumference; + this.updateElement(arc, i, properties, mode); + } + } + calculateTotal() { + const meta = this._cachedMeta; + const metaData = meta.data; + let total = 0; + let i; + for (i = 0; i < metaData.length; i++) { + const value = meta._parsed[i]; + if (value !== null && !isNaN(value) && this.chart.getDataVisibility(i) && !metaData[i].hidden) { + total += Math.abs(value); } - for (i = 0, ilen = arcs.length; i < ilen; ++i) { - options = controller.resolveDataElementOptions(i); - if (options.borderAlign !== 'inner') { - max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0); + } + return total; + } + calculateCircumference(value) { + const total = this._cachedMeta.total; + if (total > 0 && !isNaN(value)) { + return TAU * (Math.abs(value) / total); + } + return 0; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const chart = this.chart; + const labels = chart.data.labels || []; + const value = formatNumber(meta._parsed[index], chart.options.locale); + return { + label: labels[index] || '', + value, + }; + } + getMaxBorderWidth(arcs) { + let max = 0; + const chart = this.chart; + let i, ilen, meta, controller, options; + if (!arcs) { + for (i = 0, ilen = chart.data.datasets.length; i < ilen; ++i) { + if (chart.isDatasetVisible(i)) { + meta = chart.getDatasetMeta(i); + arcs = meta.data; + controller = meta.controller; + break; } } - return max; - }; - _proto.getMaxOffset = function getMaxOffset(arcs) { - let max = 0; - for (let i = 0, ilen = arcs.length; i < ilen; ++i) { - const options = this.resolveDataElementOptions(i); - max = Math.max(max, options.offset || 0, options.hoverOffset || 0); - } - return max; - } - ; - _proto._getRingWeightOffset = function _getRingWeightOffset(datasetIndex) { - let ringWeightOffset = 0; - for (let i = 0; i < datasetIndex; ++i) { - if (this.chart.isDatasetVisible(i)) { - ringWeightOffset += this._getRingWeight(i); - } + } + if (!arcs) { + return 0; + } + for (i = 0, ilen = arcs.length; i < ilen; ++i) { + options = controller.resolveDataElementOptions(i); + if (options.borderAlign !== 'inner') { + max = Math.max(max, options.borderWidth || 0, options.hoverBorderWidth || 0); } - return ringWeightOffset; } - ; - _proto._getRingWeight = function _getRingWeight(datasetIndex) { - return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0); + return max; + } + getMaxOffset(arcs) { + let max = 0; + for (let i = 0, ilen = arcs.length; i < ilen; ++i) { + const options = this.resolveDataElementOptions(i); + max = Math.max(max, options.offset || 0, options.hoverOffset || 0); } - ; - _proto._getVisibleDatasetWeightTotal = function _getVisibleDatasetWeightTotal() { - return this._getRingWeightOffset(this.chart.data.datasets.length) || 1; - }; - return DoughnutController; - }(DatasetController); - DoughnutController.id = 'doughnut'; - DoughnutController.defaults = { - datasetElementType: false, - dataElementType: 'arc', - dataElementOptions: ['backgroundColor', 'borderColor', 'borderWidth', 'borderAlign', 'offset'], - animation: { - numbers: { - type: 'number', - properties: ['circumference', 'endAngle', 'innerRadius', 'outerRadius', 'startAngle', 'x', 'y', 'offset', 'borderWidth'] - }, - animateRotate: true, - animateScale: false + return max; + } + _getRingWeightOffset(datasetIndex) { + let ringWeightOffset = 0; + for (let i = 0; i < datasetIndex; ++i) { + if (this.chart.isDatasetVisible(i)) { + ringWeightOffset += this._getRingWeight(i); + } + } + return ringWeightOffset; + } + _getRingWeight(datasetIndex) { + return Math.max(valueOrDefault(this.chart.data.datasets[datasetIndex].weight, 1), 0); + } + _getVisibleDatasetWeightTotal() { + return this._getRingWeightOffset(this.chart.data.datasets.length) || 1; + } +} +DoughnutController.id = 'doughnut'; +DoughnutController.defaults = { + datasetElementType: false, + dataElementType: 'arc', + animation: { + animateRotate: true, + animateScale: false + }, + animations: { + numbers: { + type: 'number', + properties: ['circumference', 'endAngle', 'innerRadius', 'outerRadius', 'startAngle', 'x', 'y', 'offset', 'borderWidth', 'spacing'] }, - aspectRatio: 1, + }, + cutout: '50%', + rotation: 0, + circumference: 360, + radius: '100%', + spacing: 0, + indexAxis: 'r', +}; +DoughnutController.descriptors = { + _scriptable: (name) => name !== 'spacing', + _indexable: (name) => name !== 'spacing', +}; +DoughnutController.overrides = { + aspectRatio: 1, + plugins: { legend: { labels: { - generateLabels: function generateLabels(chart) { + generateLabels(chart) { const data = chart.data; if (data.labels.length && data.datasets.length) { - return data.labels.map(function (label, i) { + const {labels: {pointStyle}} = chart.legend.options; + return data.labels.map((label, i) => { const meta = chart.getDatasetMeta(0); const style = meta.controller.getStyle(i); return { @@ -8633,6 +8441,7 @@ const Chart = (function () { fillStyle: style.backgroundColor, strokeStyle: style.borderColor, lineWidth: style.borderWidth, + pointStyle: pointStyle, hidden: !chart.getDataVisibility(i), index: i }; @@ -8641,20 +8450,17 @@ const Chart = (function () { return []; } }, - onClick: function onClick(e, legendItem, legend) { + onClick(e, legendItem, legend) { legend.chart.toggleDataVisibility(legendItem.index); legend.chart.update(); } }, - cutoutPercentage: 50, - rotation: 0, - circumference: 360, - tooltips: { + tooltip: { callbacks: { - title: function title() { + title() { return ''; }, - label: function label(tooltipItem) { + label(tooltipItem) { let dataLabel = tooltipItem.label; const value = ': ' + tooltipItem.formattedValue; if (isArray(dataLabel)) { @@ -8667,329 +8473,243 @@ const Chart = (function () { } } } - }; + } +}; - const LineController = function (_DatasetController) { - _inheritsLoose(LineController, _DatasetController); - function LineController() { - return _DatasetController.apply(this, arguments) || this; - } - const _proto = LineController.prototype; - _proto.initialize = function initialize() { - this.enableOptionSharing = true; - _DatasetController.prototype.initialize.call(this); - }; - _proto.update = function update(mode) { - const me = this; - const meta = me._cachedMeta; - const line = meta.dataset, - _meta$data = meta.data, - points = _meta$data === void 0 ? [] : _meta$data; - const animationsDisabled = me.chart._animationsDisabled; - let _getStartAndCountOfVi = getStartAndCountOfVisiblePoints(meta, points, animationsDisabled), - start = _getStartAndCountOfVi.start, - count = _getStartAndCountOfVi.count; - me._drawStart = start; - me._drawCount = count; - if (scaleRangesChanged(meta) && !animationsDisabled) { - start = 0; - count = points.length; - } - if (mode !== 'resize') { - const properties = { - points: points, - options: me.resolveDatasetElementOptions() - }; - me.updateElement(line, undefined, properties, mode); - } - me.updateElements(points, start, count, mode); - }; - _proto.updateElements = function updateElements(points, start, count, mode) { - const me = this; - const reset = mode === 'reset'; - const _me$_cachedMeta = me._cachedMeta, - xScale = _me$_cachedMeta.xScale, - yScale = _me$_cachedMeta.yScale, - _stacked = _me$_cachedMeta._stacked; - const firstOpts = me.resolveDataElementOptions(start, mode); - const sharedOptions = me.getSharedOptions(firstOpts); - const includeOptions = me.includeOptions(mode, sharedOptions); - const spanGaps = valueOrDefault(me._config.spanGaps, me.chart.options.spanGaps); - const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY; - let prevParsed = start > 0 && me.getParsed(start - 1); - for (let i = start; i < start + count; ++i) { - const point = points[i]; - const parsed = me.getParsed(i); - const x = xScale.getPixelForValue(parsed.x, i); - const y = reset ? yScale.getBasePixel() : yScale.getPixelForValue(_stacked ? me.applyStack(yScale, parsed) : parsed.y, i); - const properties = { - x: x, - y: y, - skip: isNaN(x) || isNaN(y), - stop: i > 0 && parsed.x - prevParsed.x > maxGapLength - }; - if (includeOptions) { - properties.options = sharedOptions || me.resolveDataElementOptions(i, mode); - } - me.updateElement(point, i, properties, mode); - prevParsed = parsed; - } - me.updateSharedOptions(sharedOptions, mode, firstOpts); - } - ; - _proto.resolveDatasetElementOptions = function resolveDatasetElementOptions(active) { - const me = this; - const config = me._config; - const options = me.chart.options; - const lineOptions = options.elements.line; - const values = _DatasetController.prototype.resolveDatasetElementOptions.call(this, active); - const showLine = valueOrDefault(config.showLine, options.showLine); - values.spanGaps = valueOrDefault(config.spanGaps, options.spanGaps); - values.tension = valueOrDefault(config.tension, lineOptions.tension); - values.stepped = resolve([config.stepped, lineOptions.stepped]); - if (!showLine) { - values.borderWidth = 0; - } - return values; - } - ; - _proto.getMaxOverflow = function getMaxOverflow() { - const me = this; - const meta = me._cachedMeta; - const border = meta.dataset.options.borderWidth || 0; - const data = meta.data || []; - if (!data.length) { - return border; - } - const firstPoint = data[0].size(); - const lastPoint = data[data.length - 1].size(); - return Math.max(border, firstPoint, lastPoint) / 2; - }; - _proto.draw = function draw() { - this._cachedMeta.dataset.updateControlPoints(this.chart.chartArea); - _DatasetController.prototype.draw.call(this); - }; - return LineController; - }(DatasetController); - LineController.id = 'line'; - LineController.defaults = { - datasetElementType: 'line', - datasetElementOptions: ['backgroundColor', 'borderCapStyle', 'borderColor', 'borderDash', 'borderDashOffset', 'borderJoinStyle', 'borderWidth', 'capBezierPoints', 'cubicInterpolationMode', 'fill'], - dataElementType: 'point', - dataElementOptions: { - backgroundColor: 'pointBackgroundColor', - borderColor: 'pointBorderColor', - borderWidth: 'pointBorderWidth', - hitRadius: 'pointHitRadius', - hoverHitRadius: 'pointHitRadius', - hoverBackgroundColor: 'pointHoverBackgroundColor', - hoverBorderColor: 'pointHoverBorderColor', - hoverBorderWidth: 'pointHoverBorderWidth', - hoverRadius: 'pointHoverRadius', - pointStyle: 'pointStyle', - radius: 'pointRadius', - rotation: 'pointRotation' +class LineController extends DatasetController { + initialize() { + this.enableOptionSharing = true; + this.supportsDecimation = true; + super.initialize(); + } + update(mode) { + const meta = this._cachedMeta; + const {dataset: line, data: points = [], _dataset} = meta; + const animationsDisabled = this.chart._animationsDisabled; + let {start, count} = _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled); + this._drawStart = start; + this._drawCount = count; + if (_scaleRangesChanged(meta)) { + start = 0; + count = points.length; + } + line._chart = this.chart; + line._datasetIndex = this.index; + line._decimated = !!_dataset._decimated; + line.points = points; + const options = this.resolveDatasetElementOptions(mode); + if (!this.options.showLine) { + options.borderWidth = 0; + } + options.segment = this.options.segment; + this.updateElement(line, undefined, { + animated: !animationsDisabled, + options + }, mode); + this.updateElements(points, start, count, mode); + } + updateElements(points, start, count, mode) { + const reset = mode === 'reset'; + const {iScale, vScale, _stacked, _dataset} = this._cachedMeta; + const {sharedOptions, includeOptions} = this._getSharedOptions(start, mode); + const iAxis = iScale.axis; + const vAxis = vScale.axis; + const {spanGaps, segment} = this.options; + const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY; + const directUpdate = this.chart._animationsDisabled || reset || mode === 'none'; + let prevParsed = start > 0 && this.getParsed(start - 1); + for (let i = start; i < start + count; ++i) { + const point = points[i]; + const parsed = this.getParsed(i); + const properties = directUpdate ? point : {}; + const nullData = isNullOrUndef(parsed[vAxis]); + const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i); + const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i); + properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData; + properties.stop = i > 0 && (Math.abs(parsed[iAxis] - prevParsed[iAxis])) > maxGapLength; + if (segment) { + properties.parsed = parsed; + properties.raw = _dataset.data[i]; + } + if (includeOptions) { + properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode); + } + if (!directUpdate) { + this.updateElement(point, i, properties, mode); + } + prevParsed = parsed; + } + } + getMaxOverflow() { + const meta = this._cachedMeta; + const dataset = meta.dataset; + const border = dataset.options && dataset.options.borderWidth || 0; + const data = meta.data || []; + if (!data.length) { + return border; + } + const firstPoint = data[0].size(this.resolveDataElementOptions(0)); + const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1)); + return Math.max(border, firstPoint, lastPoint) / 2; + } + draw() { + const meta = this._cachedMeta; + meta.dataset.updateControlPoints(this.chart.chartArea, meta.iScale.axis); + super.draw(); + } +} +LineController.id = 'line'; +LineController.defaults = { + datasetElementType: 'line', + dataElementType: 'point', + showLine: true, + spanGaps: false, +}; +LineController.overrides = { + scales: { + _index_: { + type: 'category', }, - showLine: true, - spanGaps: false, - interaction: { - mode: 'index' + _value_: { + type: 'linear', }, - hover: {}, - scales: { - _index_: { - type: 'category' - }, - _value_: { - type: 'linear' - } - } - }; - function getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) { - const pointCount = points.length; - let start = 0; - let count = pointCount; - if (meta._sorted) { - const iScale = meta.iScale, - _parsed = meta._parsed; - const axis = iScale.axis; - const _iScale$getUserBounds = iScale.getUserBounds(), - min = _iScale$getUserBounds.min, - max = _iScale$getUserBounds.max, - minDefined = _iScale$getUserBounds.minDefined, - maxDefined = _iScale$getUserBounds.maxDefined; - if (minDefined) { - start = _limitValue(Math.min(_lookupByKey(_parsed, iScale.axis, min).lo, animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo), 0, pointCount - 1); - } - if (maxDefined) { - count = _limitValue(Math.max(_lookupByKey(_parsed, iScale.axis, max).hi + 1, animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max)).hi + 1), start, pointCount) - start; - } else { - count = pointCount - start; - } - } + } +}; + +class PolarAreaController extends DatasetController { + constructor(chart, datasetIndex) { + super(chart, datasetIndex); + this.innerRadius = undefined; + this.outerRadius = undefined; + } + getLabelAndValue(index) { + const meta = this._cachedMeta; + const chart = this.chart; + const labels = chart.data.labels || []; + const value = formatNumber(meta._parsed[index].r, chart.options.locale); return { - start: start, - count: count + label: labels[index] || '', + value, }; } - function scaleRangesChanged(meta) { - const xScale = meta.xScale, - yScale = meta.yScale, - _scaleRanges = meta._scaleRanges; - const newRanges = { - xmin: xScale.min, - xmax: xScale.max, - ymin: yScale.min, - ymax: yScale.max - }; - if (!_scaleRanges) { - meta._scaleRanges = newRanges; - return true; - } - const changed = _scaleRanges.xmin !== xScale.min || _scaleRanges.xmax !== xScale.max || _scaleRanges.ymin !== yScale.min || _scaleRanges.ymax !== yScale.max; - _extends(_scaleRanges, newRanges); - return changed; + parseObjectData(meta, data, start, count) { + return _parseObjectDataRadialScale.bind(this)(meta, data, start, count); } - - function getStartAngleRadians(deg) { - return toRadians(deg) - 0.5 * PI; - } - const PolarAreaController = function (_DatasetController) { - _inheritsLoose(PolarAreaController, _DatasetController); - function PolarAreaController(chart, datasetIndex) { - let _this; - _this = _DatasetController.call(this, chart, datasetIndex) || this; - _this.innerRadius = undefined; - _this.outerRadius = undefined; - return _this; - } - const _proto = PolarAreaController.prototype; - _proto.update = function update(mode) { - const arcs = this._cachedMeta.data; - this._updateRadius(); - this.updateElements(arcs, 0, arcs.length, mode); - } - ; - _proto._updateRadius = function _updateRadius() { - const me = this; - const chart = me.chart; - const chartArea = chart.chartArea; - const opts = chart.options; - const minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top); - const outerRadius = Math.max(minSize / 2, 0); - const innerRadius = Math.max(opts.cutoutPercentage ? outerRadius / 100 * opts.cutoutPercentage : 1, 0); - const radiusLength = (outerRadius - innerRadius) / chart.getVisibleDatasetCount(); - me.outerRadius = outerRadius - radiusLength * me.index; - me.innerRadius = me.outerRadius - radiusLength; - }; - _proto.updateElements = function updateElements(arcs, start, count, mode) { - const me = this; - const reset = mode === 'reset'; - const chart = me.chart; - const dataset = me.getDataset(); - const opts = chart.options; - const animationOpts = opts.animation; - const scale = me._cachedMeta.rScale; - const centerX = scale.xCenter; - const centerY = scale.yCenter; - const datasetStartAngle = getStartAngleRadians(opts.startAngle); - let angle = datasetStartAngle; - let i; - me._cachedMeta.count = me.countVisibleElements(); - for (i = 0; i < start; ++i) { - angle += me._computeAngle(i, mode); - } - for (i = start; i < start + count; i++) { - const arc = arcs[i]; - let startAngle = angle; - let endAngle = angle + me._computeAngle(i, mode); - let outerRadius = this.chart.getDataVisibility(i) ? scale.getDistanceFromCenterForValue(dataset.data[i]) : 0; - angle = endAngle; - if (reset) { - if (animationOpts.animateScale) { - outerRadius = 0; - } - if (animationOpts.animateRotate) { - startAngle = datasetStartAngle; - endAngle = datasetStartAngle; - } - } - const properties = { - x: centerX, - y: centerY, - innerRadius: 0, - outerRadius: outerRadius, - startAngle: startAngle, - endAngle: endAngle, - options: me.resolveDataElementOptions(i, mode) - }; - me.updateElement(arc, i, properties, mode); - } - }; - _proto.countVisibleElements = function countVisibleElements() { - const _this2 = this; - const dataset = this.getDataset(); - const meta = this._cachedMeta; - let count = 0; - meta.data.forEach(function (element, index) { - if (!isNaN(dataset.data[index]) && _this2.chart.getDataVisibility(index)) { - count++; + update(mode) { + const arcs = this._cachedMeta.data; + this._updateRadius(); + this.updateElements(arcs, 0, arcs.length, mode); + } + getMinMax() { + const meta = this._cachedMeta; + const range = {min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY}; + meta.data.forEach((element, index) => { + const parsed = this.getParsed(index).r; + if (!isNaN(parsed) && this.chart.getDataVisibility(index)) { + if (parsed < range.min) { + range.min = parsed; } - }); - return count; - } - ; - _proto._computeAngle = function _computeAngle(index, mode) { - const me = this; - const meta = me._cachedMeta; - const count = meta.count; - const dataset = me.getDataset(); - if (isNaN(dataset.data[index]) || !this.chart.getDataVisibility(index)) { - return 0; - } - const context = me.getContext(index, mode === 'active'); - return toRadians(resolve([me.chart.options.elements.arc.angle, 360 / count], context, index)); - }; - return PolarAreaController; - }(DatasetController); - PolarAreaController.id = 'polarArea'; - PolarAreaController.defaults = { - dataElementType: 'arc', - dataElementOptions: ['backgroundColor', 'borderColor', 'borderWidth', 'borderAlign', 'offset'], - animation: { - numbers: { - type: 'number', - properties: ['x', 'y', 'startAngle', 'endAngle', 'innerRadius', 'outerRadius'] - }, - animateRotate: true, - animateScale: true - }, - aspectRatio: 1, - datasets: { - indexAxis: 'r' - }, - scales: { - r: { - type: 'radialLinear', - angleLines: { - display: false - }, - beginAtZero: true, - gridLines: { - circular: true - }, - pointLabels: { - display: false + if (parsed > range.max) { + range.max = parsed; } } + }); + return range; + } + _updateRadius() { + const chart = this.chart; + const chartArea = chart.chartArea; + const opts = chart.options; + const minSize = Math.min(chartArea.right - chartArea.left, chartArea.bottom - chartArea.top); + const outerRadius = Math.max(minSize / 2, 0); + const innerRadius = Math.max(opts.cutoutPercentage ? (outerRadius / 100) * (opts.cutoutPercentage) : 1, 0); + const radiusLength = (outerRadius - innerRadius) / chart.getVisibleDatasetCount(); + this.outerRadius = outerRadius - (radiusLength * this.index); + this.innerRadius = this.outerRadius - radiusLength; + } + updateElements(arcs, start, count, mode) { + const reset = mode === 'reset'; + const chart = this.chart; + const opts = chart.options; + const animationOpts = opts.animation; + const scale = this._cachedMeta.rScale; + const centerX = scale.xCenter; + const centerY = scale.yCenter; + const datasetStartAngle = scale.getIndexAngle(0) - 0.5 * PI; + let angle = datasetStartAngle; + let i; + const defaultAngle = 360 / this.countVisibleElements(); + for (i = 0; i < start; ++i) { + angle += this._computeAngle(i, mode, defaultAngle); + } + for (i = start; i < start + count; i++) { + const arc = arcs[i]; + let startAngle = angle; + let endAngle = angle + this._computeAngle(i, mode, defaultAngle); + let outerRadius = chart.getDataVisibility(i) ? scale.getDistanceFromCenterForValue(this.getParsed(i).r) : 0; + angle = endAngle; + if (reset) { + if (animationOpts.animateScale) { + outerRadius = 0; + } + if (animationOpts.animateRotate) { + startAngle = endAngle = datasetStartAngle; + } + } + const properties = { + x: centerX, + y: centerY, + innerRadius: 0, + outerRadius, + startAngle, + endAngle, + options: this.resolveDataElementOptions(i, arc.active ? 'active' : mode) + }; + this.updateElement(arc, i, properties, mode); + } + } + countVisibleElements() { + const meta = this._cachedMeta; + let count = 0; + meta.data.forEach((element, index) => { + if (!isNaN(this.getParsed(index).r) && this.chart.getDataVisibility(index)) { + count++; + } + }); + return count; + } + _computeAngle(index, mode, defaultAngle) { + return this.chart.getDataVisibility(index) + ? toRadians(this.resolveDataElementOptions(index, mode).angle || defaultAngle) + : 0; + } +} +PolarAreaController.id = 'polarArea'; +PolarAreaController.defaults = { + dataElementType: 'arc', + animation: { + animateRotate: true, + animateScale: true + }, + animations: { + numbers: { + type: 'number', + properties: ['x', 'y', 'startAngle', 'endAngle', 'innerRadius', 'outerRadius'] }, - startAngle: 0, + }, + indexAxis: 'r', + startAngle: 0, +}; +PolarAreaController.overrides = { + aspectRatio: 1, + plugins: { legend: { labels: { - generateLabels: function generateLabels(chart) { + generateLabels(chart) { const data = chart.data; if (data.labels.length && data.datasets.length) { - return data.labels.map(function (label, i) { + const {labels: {pointStyle}} = chart.legend.options; + return data.labels.map((label, i) => { const meta = chart.getDatasetMeta(0); const style = meta.controller.getStyle(i); return { @@ -8997,6 +8717,7 @@ const Chart = (function () { fillStyle: style.backgroundColor, strokeStyle: style.borderColor, lineWidth: style.borderWidth, + pointStyle: pointStyle, hidden: !chart.getDataVisibility(i), index: i }; @@ -9005,4696 +8726,4800 @@ const Chart = (function () { return []; } }, - onClick: function onClick(e, legendItem, legend) { + onClick(e, legendItem, legend) { legend.chart.toggleDataVisibility(legendItem.index); legend.chart.update(); } }, - tooltips: { + tooltip: { callbacks: { - title: function title() { + title() { return ''; }, - label: function label(context) { + label(context) { return context.chart.data.labels[context.dataIndex] + ': ' + context.formattedValue; } } } - }; + }, + scales: { + r: { + type: 'radialLinear', + angleLines: { + display: false + }, + beginAtZero: true, + grid: { + circular: true + }, + pointLabels: { + display: false + }, + startAngle: 0 + } + } +}; - const PieController = function (_DoughnutController) { - _inheritsLoose(PieController, _DoughnutController); - function PieController() { - return _DoughnutController.apply(this, arguments) || this; - } - return PieController; - }(DoughnutController); - PieController.id = 'pie'; - PieController.defaults = { - cutoutPercentage: 0 - }; +class PieController extends DoughnutController { +} +PieController.id = 'pie'; +PieController.defaults = { + cutout: 0, + rotation: 0, + circumference: 360, + radius: '100%' +}; - const RadarController = function (_DatasetController) { - _inheritsLoose(RadarController, _DatasetController); - function RadarController() { - return _DatasetController.apply(this, arguments) || this; - } - const _proto = RadarController.prototype; - _proto.getLabelAndValue = function getLabelAndValue(index) { - const me = this; - const vScale = me._cachedMeta.vScale; - const parsed = me.getParsed(index); - return { - label: vScale.getLabels()[index], - value: '' + vScale.getLabelForValue(parsed[vScale.axis]) +class RadarController extends DatasetController { + getLabelAndValue(index) { + const vScale = this._cachedMeta.vScale; + const parsed = this.getParsed(index); + return { + label: vScale.getLabels()[index], + value: '' + vScale.getLabelForValue(parsed[vScale.axis]) + }; + } + parseObjectData(meta, data, start, count) { + return _parseObjectDataRadialScale.bind(this)(meta, data, start, count); + } + update(mode) { + const meta = this._cachedMeta; + const line = meta.dataset; + const points = meta.data || []; + const labels = meta.iScale.getLabels(); + line.points = points; + if (mode !== 'resize') { + const options = this.resolveDatasetElementOptions(mode); + if (!this.options.showLine) { + options.borderWidth = 0; + } + const properties = { + _loop: true, + _fullLoop: labels.length === points.length, + options }; - }; - _proto.update = function update(mode) { - const me = this; - const meta = me._cachedMeta; - const line = meta.dataset; - const points = meta.data || []; - const labels = meta.iScale.getLabels(); - if (mode !== 'resize') { - const properties = { - points: points, - _loop: true, - _fullLoop: labels.length === points.length, - options: me.resolveDatasetElementOptions() - }; - me.updateElement(line, undefined, properties, mode); - } - me.updateElements(points, 0, points.length, mode); - }; - _proto.updateElements = function updateElements(points, start, count, mode) { - const me = this; - const dataset = me.getDataset(); - const scale = me._cachedMeta.rScale; - const reset = mode === 'reset'; - for (let i = start; i < start + count; i++) { - const point = points[i]; - const options = me.resolveDataElementOptions(i, mode); - const pointPosition = scale.getPointPositionForValue(i, dataset.data[i]); - const x = reset ? scale.xCenter : pointPosition.x; - const y = reset ? scale.yCenter : pointPosition.y; - const properties = { - x: x, - y: y, - angle: pointPosition.angle, - skip: isNaN(x) || isNaN(y), - options: options - }; - me.updateElement(point, i, properties, mode); - } - } - ; - _proto.resolveDatasetElementOptions = function resolveDatasetElementOptions(active) { - const me = this; - const config = me._config; - const options = me.chart.options; - const values = _DatasetController.prototype.resolveDatasetElementOptions.call(this, active); - const showLine = valueOrDefault(config.showLine, options.showLine); - values.spanGaps = valueOrDefault(config.spanGaps, options.spanGaps); - values.tension = valueOrDefault(config.tension, options.elements.line.tension); - if (!showLine) { - values.borderWidth = 0; - } - return values; - }; - return RadarController; - }(DatasetController); - RadarController.id = 'radar'; - RadarController.defaults = { - datasetElementType: 'line', - datasetElementOptions: ['backgroundColor', 'borderColor', 'borderCapStyle', 'borderDash', 'borderDashOffset', 'borderJoinStyle', 'borderWidth', 'fill'], - dataElementType: 'point', - dataElementOptions: { - backgroundColor: 'pointBackgroundColor', - borderColor: 'pointBorderColor', - borderWidth: 'pointBorderWidth', - hitRadius: 'pointHitRadius', - hoverBackgroundColor: 'pointHoverBackgroundColor', - hoverBorderColor: 'pointHoverBorderColor', - hoverBorderWidth: 'pointHoverBorderWidth', - hoverRadius: 'pointHoverRadius', - pointStyle: 'pointStyle', - radius: 'pointRadius', - rotation: 'pointRotation' - }, - aspectRatio: 1, - spanGaps: false, - scales: { - r: { - type: 'radialLinear' - } - }, - datasets: { - indexAxis: 'r' - }, - elements: { - line: { - fill: 'start', - tension: 0 - } - } - }; + this.updateElement(line, undefined, properties, mode); + } + this.updateElements(points, 0, points.length, mode); + } + updateElements(points, start, count, mode) { + const scale = this._cachedMeta.rScale; + const reset = mode === 'reset'; + for (let i = start; i < start + count; i++) { + const point = points[i]; + const options = this.resolveDataElementOptions(i, point.active ? 'active' : mode); + const pointPosition = scale.getPointPositionForValue(i, this.getParsed(i).r); + const x = reset ? scale.xCenter : pointPosition.x; + const y = reset ? scale.yCenter : pointPosition.y; + const properties = { + x, + y, + angle: pointPosition.angle, + skip: isNaN(x) || isNaN(y), + options + }; + this.updateElement(point, i, properties, mode); + } + } +} +RadarController.id = 'radar'; +RadarController.defaults = { + datasetElementType: 'line', + dataElementType: 'point', + indexAxis: 'r', + showLine: true, + elements: { + line: { + fill: 'start' + } + }, +}; +RadarController.overrides = { + aspectRatio: 1, + scales: { + r: { + type: 'radialLinear', + } + } +}; - const ScatterController = function (_LineController) { - _inheritsLoose(ScatterController, _LineController); - function ScatterController() { - return _LineController.apply(this, arguments) || this; - } - return ScatterController; - }(LineController); - ScatterController.id = 'scatter'; - ScatterController.defaults = { - scales: { - x: { - type: 'linear' - }, - y: { - type: 'linear' +class ScatterController extends DatasetController { + update(mode) { + const meta = this._cachedMeta; + const {data: points = []} = meta; + const animationsDisabled = this.chart._animationsDisabled; + let {start, count} = _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled); + this._drawStart = start; + this._drawCount = count; + if (_scaleRangesChanged(meta)) { + start = 0; + count = points.length; + } + if (this.options.showLine) { + const {dataset: line, _dataset} = meta; + line._chart = this.chart; + line._datasetIndex = this.index; + line._decimated = !!_dataset._decimated; + line.points = points; + const options = this.resolveDatasetElementOptions(mode); + options.segment = this.options.segment; + this.updateElement(line, undefined, { + animated: !animationsDisabled, + options + }, mode); + } + this.updateElements(points, start, count, mode); + } + addElements() { + const {showLine} = this.options; + if (!this.datasetElementType && showLine) { + this.datasetElementType = registry.getElement('line'); + } + super.addElements(); + } + updateElements(points, start, count, mode) { + const reset = mode === 'reset'; + const {iScale, vScale, _stacked, _dataset} = this._cachedMeta; + const firstOpts = this.resolveDataElementOptions(start, mode); + const sharedOptions = this.getSharedOptions(firstOpts); + const includeOptions = this.includeOptions(mode, sharedOptions); + const iAxis = iScale.axis; + const vAxis = vScale.axis; + const {spanGaps, segment} = this.options; + const maxGapLength = isNumber(spanGaps) ? spanGaps : Number.POSITIVE_INFINITY; + const directUpdate = this.chart._animationsDisabled || reset || mode === 'none'; + let prevParsed = start > 0 && this.getParsed(start - 1); + for (let i = start; i < start + count; ++i) { + const point = points[i]; + const parsed = this.getParsed(i); + const properties = directUpdate ? point : {}; + const nullData = isNullOrUndef(parsed[vAxis]); + const iPixel = properties[iAxis] = iScale.getPixelForValue(parsed[iAxis], i); + const vPixel = properties[vAxis] = reset || nullData ? vScale.getBasePixel() : vScale.getPixelForValue(_stacked ? this.applyStack(vScale, parsed, _stacked) : parsed[vAxis], i); + properties.skip = isNaN(iPixel) || isNaN(vPixel) || nullData; + properties.stop = i > 0 && (Math.abs(parsed[iAxis] - prevParsed[iAxis])) > maxGapLength; + if (segment) { + properties.parsed = parsed; + properties.raw = _dataset.data[i]; + } + if (includeOptions) { + properties.options = sharedOptions || this.resolveDataElementOptions(i, point.active ? 'active' : mode); + } + if (!directUpdate) { + this.updateElement(point, i, properties, mode); + } + prevParsed = parsed; + } + this.updateSharedOptions(sharedOptions, mode, firstOpts); + } + getMaxOverflow() { + const meta = this._cachedMeta; + const data = meta.data || []; + if (!this.options.showLine) { + let max = 0; + for (let i = data.length - 1; i >= 0; --i) { + max = Math.max(max, data[i].size(this.resolveDataElementOptions(i)) / 2); } - }, - datasets: { - showLine: false, - fill: false - }, - tooltips: { + return max > 0 && max; + } + const dataset = meta.dataset; + const border = dataset.options && dataset.options.borderWidth || 0; + if (!data.length) { + return border; + } + const firstPoint = data[0].size(this.resolveDataElementOptions(0)); + const lastPoint = data[data.length - 1].size(this.resolveDataElementOptions(data.length - 1)); + return Math.max(border, firstPoint, lastPoint) / 2; + } +} +ScatterController.id = 'scatter'; +ScatterController.defaults = { + datasetElementType: false, + dataElementType: 'point', + showLine: false, + fill: false +}; +ScatterController.overrides = { + interaction: { + mode: 'point' + }, + plugins: { + tooltip: { callbacks: { - title: function title() { + title() { return ''; }, - label: function label(item) { + label(item) { return '(' + item.label + ', ' + item.formattedValue + ')'; } } } - }; + }, + scales: { + x: { + type: 'linear' + }, + y: { + type: 'linear' + } + } +}; - const controllers = /*#__PURE__*/Object.freeze({ - __proto__: null, - BarController: BarController, - BubbleController: BubbleController, - DoughnutController: DoughnutController, - LineController: LineController, - PolarAreaController: PolarAreaController, - PieController: PieController, - RadarController: RadarController, - ScatterController: ScatterController - }); +var controllers = /*#__PURE__*/Object.freeze({ +__proto__: null, +BarController: BarController, +BubbleController: BubbleController, +DoughnutController: DoughnutController, +LineController: LineController, +PolarAreaController: PolarAreaController, +PieController: PieController, +RadarController: RadarController, +ScatterController: ScatterController +}); - function clipArc(ctx, element) { - const startAngle = element.startAngle, - endAngle = element.endAngle, - pixelMargin = element.pixelMargin, - x = element.x, - y = element.y, - outerRadius = element.outerRadius, - innerRadius = element.innerRadius; - let angleMargin = pixelMargin / outerRadius; - ctx.beginPath(); - ctx.arc(x, y, outerRadius, startAngle - angleMargin, endAngle + angleMargin); - if (innerRadius > pixelMargin) { - angleMargin = pixelMargin / innerRadius; - ctx.arc(x, y, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true); - } else { - ctx.arc(x, y, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI); +function clipArc(ctx, element, endAngle) { + const {startAngle, pixelMargin, x, y, outerRadius, innerRadius} = element; + let angleMargin = pixelMargin / outerRadius; + ctx.beginPath(); + ctx.arc(x, y, outerRadius, startAngle - angleMargin, endAngle + angleMargin); + if (innerRadius > pixelMargin) { + angleMargin = pixelMargin / innerRadius; + ctx.arc(x, y, innerRadius, endAngle + angleMargin, startAngle - angleMargin, true); + } else { + ctx.arc(x, y, pixelMargin, endAngle + HALF_PI, startAngle - HALF_PI); + } + ctx.closePath(); + ctx.clip(); +} +function toRadiusCorners(value) { + return _readValueToProps(value, ['outerStart', 'outerEnd', 'innerStart', 'innerEnd']); +} +function parseBorderRadius$1(arc, innerRadius, outerRadius, angleDelta) { + const o = toRadiusCorners(arc.options.borderRadius); + const halfThickness = (outerRadius - innerRadius) / 2; + const innerLimit = Math.min(halfThickness, angleDelta * innerRadius / 2); + const computeOuterLimit = (val) => { + const outerArcLimit = (outerRadius - Math.min(halfThickness, val)) * angleDelta / 2; + return _limitValue(val, 0, Math.min(halfThickness, outerArcLimit)); + }; + return { + outerStart: computeOuterLimit(o.outerStart), + outerEnd: computeOuterLimit(o.outerEnd), + innerStart: _limitValue(o.innerStart, 0, innerLimit), + innerEnd: _limitValue(o.innerEnd, 0, innerLimit), + }; +} +function rThetaToXY(r, theta, x, y) { + return { + x: x + r * Math.cos(theta), + y: y + r * Math.sin(theta), + }; +} +function pathArc(ctx, element, offset, spacing, end, circular) { + const {x, y, startAngle: start, pixelMargin, innerRadius: innerR} = element; + const outerRadius = Math.max(element.outerRadius + spacing + offset - pixelMargin, 0); + const innerRadius = innerR > 0 ? innerR + spacing + offset + pixelMargin : 0; + let spacingOffset = 0; + const alpha = end - start; + if (spacing) { + const noSpacingInnerRadius = innerR > 0 ? innerR - spacing : 0; + const noSpacingOuterRadius = outerRadius > 0 ? outerRadius - spacing : 0; + const avNogSpacingRadius = (noSpacingInnerRadius + noSpacingOuterRadius) / 2; + const adjustedAngle = avNogSpacingRadius !== 0 ? (alpha * avNogSpacingRadius) / (avNogSpacingRadius + spacing) : alpha; + spacingOffset = (alpha - adjustedAngle) / 2; + } + const beta = Math.max(0.001, alpha * outerRadius - offset / PI) / outerRadius; + const angleOffset = (alpha - beta) / 2; + const startAngle = start + angleOffset + spacingOffset; + const endAngle = end - angleOffset - spacingOffset; + const {outerStart, outerEnd, innerStart, innerEnd} = parseBorderRadius$1(element, innerRadius, outerRadius, endAngle - startAngle); + const outerStartAdjustedRadius = outerRadius - outerStart; + const outerEndAdjustedRadius = outerRadius - outerEnd; + const outerStartAdjustedAngle = startAngle + outerStart / outerStartAdjustedRadius; + const outerEndAdjustedAngle = endAngle - outerEnd / outerEndAdjustedRadius; + const innerStartAdjustedRadius = innerRadius + innerStart; + const innerEndAdjustedRadius = innerRadius + innerEnd; + const innerStartAdjustedAngle = startAngle + innerStart / innerStartAdjustedRadius; + const innerEndAdjustedAngle = endAngle - innerEnd / innerEndAdjustedRadius; + ctx.beginPath(); + if (circular) { + ctx.arc(x, y, outerRadius, outerStartAdjustedAngle, outerEndAdjustedAngle); + if (outerEnd > 0) { + const pCenter = rThetaToXY(outerEndAdjustedRadius, outerEndAdjustedAngle, x, y); + ctx.arc(pCenter.x, pCenter.y, outerEnd, outerEndAdjustedAngle, endAngle + HALF_PI); + } + const p4 = rThetaToXY(innerEndAdjustedRadius, endAngle, x, y); + ctx.lineTo(p4.x, p4.y); + if (innerEnd > 0) { + const pCenter = rThetaToXY(innerEndAdjustedRadius, innerEndAdjustedAngle, x, y); + ctx.arc(pCenter.x, pCenter.y, innerEnd, endAngle + HALF_PI, innerEndAdjustedAngle + Math.PI); + } + ctx.arc(x, y, innerRadius, endAngle - (innerEnd / innerRadius), startAngle + (innerStart / innerRadius), true); + if (innerStart > 0) { + const pCenter = rThetaToXY(innerStartAdjustedRadius, innerStartAdjustedAngle, x, y); + ctx.arc(pCenter.x, pCenter.y, innerStart, innerStartAdjustedAngle + Math.PI, startAngle - HALF_PI); + } + const p8 = rThetaToXY(outerStartAdjustedRadius, startAngle, x, y); + ctx.lineTo(p8.x, p8.y); + if (outerStart > 0) { + const pCenter = rThetaToXY(outerStartAdjustedRadius, outerStartAdjustedAngle, x, y); + ctx.arc(pCenter.x, pCenter.y, outerStart, startAngle - HALF_PI, outerStartAdjustedAngle); + } + } else { + ctx.moveTo(x, y); + const outerStartX = Math.cos(outerStartAdjustedAngle) * outerRadius + x; + const outerStartY = Math.sin(outerStartAdjustedAngle) * outerRadius + y; + ctx.lineTo(outerStartX, outerStartY); + const outerEndX = Math.cos(outerEndAdjustedAngle) * outerRadius + x; + const outerEndY = Math.sin(outerEndAdjustedAngle) * outerRadius + y; + ctx.lineTo(outerEndX, outerEndY); + } + ctx.closePath(); +} +function drawArc(ctx, element, offset, spacing, circular) { + const {fullCircles, startAngle, circumference} = element; + let endAngle = element.endAngle; + if (fullCircles) { + pathArc(ctx, element, offset, spacing, startAngle + TAU, circular); + for (let i = 0; i < fullCircles; ++i) { + ctx.fill(); } - ctx.closePath(); - ctx.clip(); - } - function pathArc(ctx, element) { - const x = element.x, - y = element.y, - startAngle = element.startAngle, - endAngle = element.endAngle, - pixelMargin = element.pixelMargin; - const outerRadius = Math.max(element.outerRadius - pixelMargin, 0); - const innerRadius = element.innerRadius + pixelMargin; - ctx.beginPath(); - ctx.arc(x, y, outerRadius, startAngle, endAngle); - ctx.arc(x, y, innerRadius, endAngle, startAngle, true); - ctx.closePath(); - } - function drawArc(ctx, element) { - if (element.fullCircles) { - element.endAngle = element.startAngle + TAU; - pathArc(ctx, element); - for (let i = 0; i < element.fullCircles; ++i) { - ctx.fill(); + if (!isNaN(circumference)) { + endAngle = startAngle + circumference % TAU; + if (circumference % TAU === 0) { + endAngle += TAU; } - element.endAngle = element.startAngle + element.circumference % TAU; } - pathArc(ctx, element); - ctx.fill(); } - function drawFullCircleBorders(ctx, element, inner) { - const x = element.x, - y = element.y, - startAngle = element.startAngle, - endAngle = element.endAngle, - pixelMargin = element.pixelMargin; - const outerRadius = Math.max(element.outerRadius - pixelMargin, 0); - const innerRadius = element.innerRadius + pixelMargin; - let i; - if (inner) { - element.endAngle = element.startAngle + TAU; - clipArc(ctx, element); - element.endAngle = endAngle; - if (element.endAngle === element.startAngle) { - element.endAngle += TAU; - element.fullCircles--; - } - } - ctx.beginPath(); - ctx.arc(x, y, innerRadius, startAngle + TAU, startAngle, true); - for (i = 0; i < element.fullCircles; ++i) { - ctx.stroke(); - } - ctx.beginPath(); - ctx.arc(x, y, outerRadius, startAngle, startAngle + TAU); - for (i = 0; i < element.fullCircles; ++i) { - ctx.stroke(); - } + pathArc(ctx, element, offset, spacing, endAngle, circular); + ctx.fill(); + return endAngle; +} +function drawFullCircleBorders(ctx, element, inner) { + const {x, y, startAngle, pixelMargin, fullCircles} = element; + const outerRadius = Math.max(element.outerRadius - pixelMargin, 0); + const innerRadius = element.innerRadius + pixelMargin; + let i; + if (inner) { + clipArc(ctx, element, startAngle + TAU); } - function drawBorder(ctx, element) { - const x = element.x, - y = element.y, - startAngle = element.startAngle, - endAngle = element.endAngle, - pixelMargin = element.pixelMargin, - options = element.options; - const outerRadius = element.outerRadius; - const innerRadius = element.innerRadius + pixelMargin; - const inner = options.borderAlign === 'inner'; - if (!options.borderWidth) { - return; - } - if (inner) { - ctx.lineWidth = options.borderWidth * 2; - ctx.lineJoin = 'round'; - } else { - ctx.lineWidth = options.borderWidth; - ctx.lineJoin = 'bevel'; - } - if (element.fullCircles) { - drawFullCircleBorders(ctx, element, inner); - } - if (inner) { - clipArc(ctx, element); - } - ctx.beginPath(); - ctx.arc(x, y, outerRadius, startAngle, endAngle); - ctx.arc(x, y, innerRadius, endAngle, startAngle, true); - ctx.closePath(); + ctx.beginPath(); + ctx.arc(x, y, innerRadius, startAngle + TAU, startAngle, true); + for (i = 0; i < fullCircles; ++i) { ctx.stroke(); } - const ArcElement = function (_Element) { - _inheritsLoose(ArcElement, _Element); - function ArcElement(cfg) { - let _this; - _this = _Element.call(this) || this; - _this.options = undefined; - _this.circumference = undefined; - _this.startAngle = undefined; - _this.endAngle = undefined; - _this.innerRadius = undefined; - _this.outerRadius = undefined; - _this.pixelMargin = 0; - _this.fullCircles = 0; - if (cfg) { - _extends(_assertThisInitialized(_this), cfg); - } - return _this; - } - const _proto = ArcElement.prototype; - _proto.inRange = function inRange(chartX, chartY, useFinalPosition) { - const point = this.getProps(['x', 'y'], useFinalPosition); - const _getAngleFromPoint = getAngleFromPoint(point, { - x: chartX, - y: chartY - }), - angle = _getAngleFromPoint.angle, - distance = _getAngleFromPoint.distance; - const _this$getProps = this.getProps(['startAngle', 'endAngle', 'innerRadius', 'outerRadius', 'circumference'], useFinalPosition), - startAngle = _this$getProps.startAngle, - endAngle = _this$getProps.endAngle, - innerRadius = _this$getProps.innerRadius, - outerRadius = _this$getProps.outerRadius, - circumference = _this$getProps.circumference; - const betweenAngles = circumference >= TAU || _angleBetween(angle, startAngle, endAngle); - const withinRadius = distance >= innerRadius && distance <= outerRadius; - return betweenAngles && withinRadius; - } - ; - _proto.getCenterPoint = function getCenterPoint(useFinalPosition) { - const _this$getProps2 = this.getProps(['x', 'y', 'startAngle', 'endAngle', 'innerRadius', 'outerRadius'], useFinalPosition), - x = _this$getProps2.x, - y = _this$getProps2.y, - startAngle = _this$getProps2.startAngle, - endAngle = _this$getProps2.endAngle, - innerRadius = _this$getProps2.innerRadius, - outerRadius = _this$getProps2.outerRadius; - const halfAngle = (startAngle + endAngle) / 2; - const halfRadius = (innerRadius + outerRadius) / 2; - return { - x: x + Math.cos(halfAngle) * halfRadius, - y: y + Math.sin(halfAngle) * halfRadius - }; - } - ; - _proto.tooltipPosition = function tooltipPosition(useFinalPosition) { - return this.getCenterPoint(useFinalPosition); - }; - _proto.draw = function draw(ctx) { - const me = this; - const options = me.options; - const offset = options.offset || 0; - me.pixelMargin = options.borderAlign === 'inner' ? 0.33 : 0; - me.fullCircles = Math.floor(me.circumference / TAU); - if (me.circumference === 0) { - return; - } - ctx.save(); - if (offset && me.circumference < TAU) { - const halfAngle = (me.startAngle + me.endAngle) / 2; - ctx.translate(Math.cos(halfAngle) * offset, Math.sin(halfAngle) * offset); - } - ctx.fillStyle = options.backgroundColor; - ctx.strokeStyle = options.borderColor; - drawArc(ctx, me); - drawBorder(ctx, me); - ctx.restore(); - }; - return ArcElement; - }(Element$1); - ArcElement.id = 'arc'; - ArcElement.defaults = { - borderAlign: 'center', - borderColor: '#fff', - borderWidth: 2, - offset: 0 - }; - ArcElement.defaultRoutes = { - backgroundColor: 'color' - }; - - function setStyle(ctx, vm) { - ctx.lineCap = vm.borderCapStyle; - ctx.setLineDash(vm.borderDash); - ctx.lineDashOffset = vm.borderDashOffset; - ctx.lineJoin = vm.borderJoinStyle; - ctx.lineWidth = vm.borderWidth; - ctx.strokeStyle = vm.borderColor; - } - function lineTo(ctx, previous, target) { - ctx.lineTo(target.x, target.y); - } - function getLineMethod(options) { - if (options.stepped) { - return _steppedLineTo; - } - if (options.tension) { - return _bezierCurveTo; - } - return lineTo; - } - function pathVars(points, segment, params) { - params = params || {}; - const count = points.length; - const start = Math.max(params.start || 0, segment.start); - const end = Math.min(params.end || count - 1, segment.end); + ctx.beginPath(); + ctx.arc(x, y, outerRadius, startAngle, startAngle + TAU); + for (i = 0; i < fullCircles; ++i) { + ctx.stroke(); + } +} +function drawBorder(ctx, element, offset, spacing, endAngle, circular) { + const {options} = element; + const {borderWidth, borderJoinStyle} = options; + const inner = options.borderAlign === 'inner'; + if (!borderWidth) { + return; + } + if (inner) { + ctx.lineWidth = borderWidth * 2; + ctx.lineJoin = borderJoinStyle || 'round'; + } else { + ctx.lineWidth = borderWidth; + ctx.lineJoin = borderJoinStyle || 'bevel'; + } + if (element.fullCircles) { + drawFullCircleBorders(ctx, element, inner); + } + if (inner) { + clipArc(ctx, element, endAngle); + } + pathArc(ctx, element, offset, spacing, endAngle, circular); + ctx.stroke(); +} +class ArcElement extends Element { + constructor(cfg) { + super(); + this.options = undefined; + this.circumference = undefined; + this.startAngle = undefined; + this.endAngle = undefined; + this.innerRadius = undefined; + this.outerRadius = undefined; + this.pixelMargin = 0; + this.fullCircles = 0; + if (cfg) { + Object.assign(this, cfg); + } + } + inRange(chartX, chartY, useFinalPosition) { + const point = this.getProps(['x', 'y'], useFinalPosition); + const {angle, distance} = getAngleFromPoint(point, {x: chartX, y: chartY}); + const {startAngle, endAngle, innerRadius, outerRadius, circumference} = this.getProps([ + 'startAngle', + 'endAngle', + 'innerRadius', + 'outerRadius', + 'circumference' + ], useFinalPosition); + const rAdjust = this.options.spacing / 2; + const _circumference = valueOrDefault(circumference, endAngle - startAngle); + const betweenAngles = _circumference >= TAU || _angleBetween(angle, startAngle, endAngle); + const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust); + return (betweenAngles && withinRadius); + } + getCenterPoint(useFinalPosition) { + const {x, y, startAngle, endAngle, innerRadius, outerRadius} = this.getProps([ + 'x', + 'y', + 'startAngle', + 'endAngle', + 'innerRadius', + 'outerRadius', + 'circumference', + ], useFinalPosition); + const {offset, spacing} = this.options; + const halfAngle = (startAngle + endAngle) / 2; + const halfRadius = (innerRadius + outerRadius + spacing + offset) / 2; return { - count: count, - start: start, - loop: segment.loop, - ilen: end < start ? count + end - start : end - start + x: x + Math.cos(halfAngle) * halfRadius, + y: y + Math.sin(halfAngle) * halfRadius }; } - function pathSegment(ctx, line, segment, params) { - const points = line.points, - options = line.options; - const _pathVars = pathVars(points, segment, params), - count = _pathVars.count, - start = _pathVars.start, - loop = _pathVars.loop, - ilen = _pathVars.ilen; - const lineMethod = getLineMethod(options); - let _ref = params || {}, - _ref$move = _ref.move, - move = _ref$move === void 0 ? true : _ref$move, - reverse = _ref.reverse; - let i, point, prev; - for (i = 0; i <= ilen; ++i) { - point = points[(start + (reverse ? ilen - i : i)) % count]; - if (point.skip) { - continue; - } else if (move) { - ctx.moveTo(point.x, point.y); - move = false; - } else { - lineMethod(ctx, prev, point, reverse, options.stepped); - } - prev = point; - } - if (loop) { - point = points[(start + (reverse ? ilen : 0)) % count]; - lineMethod(ctx, prev, point, reverse, options.stepped); + tooltipPosition(useFinalPosition) { + return this.getCenterPoint(useFinalPosition); + } + draw(ctx) { + const {options, circumference} = this; + const offset = (options.offset || 0) / 2; + const spacing = (options.spacing || 0) / 2; + const circular = options.circular; + this.pixelMargin = (options.borderAlign === 'inner') ? 0.33 : 0; + this.fullCircles = circumference > TAU ? Math.floor(circumference / TAU) : 0; + if (circumference === 0 || this.innerRadius < 0 || this.outerRadius < 0) { + return; } - return !!loop; + ctx.save(); + let radiusOffset = 0; + if (offset) { + radiusOffset = offset / 2; + const halfAngle = (this.startAngle + this.endAngle) / 2; + ctx.translate(Math.cos(halfAngle) * radiusOffset, Math.sin(halfAngle) * radiusOffset); + if (this.circumference >= PI) { + radiusOffset = offset; + } + } + ctx.fillStyle = options.backgroundColor; + ctx.strokeStyle = options.borderColor; + const endAngle = drawArc(ctx, this, radiusOffset, spacing, circular); + drawBorder(ctx, this, radiusOffset, spacing, endAngle, circular); + ctx.restore(); } - function fastPathSegment(ctx, line, segment, params) { - const points = line.points; - const _pathVars2 = pathVars(points, segment, params), - count = _pathVars2.count, - start = _pathVars2.start, - ilen = _pathVars2.ilen; - const _ref2 = params || {}, - _ref2$move = _ref2.move, - move = _ref2$move === void 0 ? true : _ref2$move, - reverse = _ref2.reverse; - let avgX = 0; - let countX = 0; - let i, point, prevX, minY, maxY, lastY; - const pointIndex = function pointIndex(index) { - return (start + (reverse ? ilen - index : index)) % count; - }; - const drawX = function drawX() { - if (minY !== maxY) { - ctx.lineTo(avgX, maxY); - ctx.lineTo(avgX, minY); - ctx.lineTo(avgX, lastY); - } - }; - if (move) { - point = points[pointIndex(0)]; +} +ArcElement.id = 'arc'; +ArcElement.defaults = { + borderAlign: 'center', + borderColor: '#fff', + borderJoinStyle: undefined, + borderRadius: 0, + borderWidth: 2, + offset: 0, + spacing: 0, + angle: undefined, + circular: true, +}; +ArcElement.defaultRoutes = { + backgroundColor: 'backgroundColor' +}; + +function setStyle(ctx, options, style = options) { + ctx.lineCap = valueOrDefault(style.borderCapStyle, options.borderCapStyle); + ctx.setLineDash(valueOrDefault(style.borderDash, options.borderDash)); + ctx.lineDashOffset = valueOrDefault(style.borderDashOffset, options.borderDashOffset); + ctx.lineJoin = valueOrDefault(style.borderJoinStyle, options.borderJoinStyle); + ctx.lineWidth = valueOrDefault(style.borderWidth, options.borderWidth); + ctx.strokeStyle = valueOrDefault(style.borderColor, options.borderColor); +} +function lineTo(ctx, previous, target) { + ctx.lineTo(target.x, target.y); +} +function getLineMethod(options) { + if (options.stepped) { + return _steppedLineTo; + } + if (options.tension || options.cubicInterpolationMode === 'monotone') { + return _bezierCurveTo; + } + return lineTo; +} +function pathVars(points, segment, params = {}) { + const count = points.length; + const {start: paramsStart = 0, end: paramsEnd = count - 1} = params; + const {start: segmentStart, end: segmentEnd} = segment; + const start = Math.max(paramsStart, segmentStart); + const end = Math.min(paramsEnd, segmentEnd); + const outside = paramsStart < segmentStart && paramsEnd < segmentStart || paramsStart > segmentEnd && paramsEnd > segmentEnd; + return { + count, + start, + loop: segment.loop, + ilen: end < start && !outside ? count + end - start : end - start + }; +} +function pathSegment(ctx, line, segment, params) { + const {points, options} = line; + const {count, start, loop, ilen} = pathVars(points, segment, params); + const lineMethod = getLineMethod(options); + let {move = true, reverse} = params || {}; + let i, point, prev; + for (i = 0; i <= ilen; ++i) { + point = points[(start + (reverse ? ilen - i : i)) % count]; + if (point.skip) { + continue; + } else if (move) { ctx.moveTo(point.x, point.y); + move = false; + } else { + lineMethod(ctx, prev, point, reverse, options.stepped); } - for (i = 0; i <= ilen; ++i) { - point = points[pointIndex(i)]; - if (point.skip) { - continue; - } - const x = point.x; - const y = point.y; - const truncX = x | 0; - if (truncX === prevX) { - if (y < minY) { - minY = y; - } else if (y > maxY) { - maxY = y; - } - avgX = (countX * avgX + x) / ++countX; - } else { - drawX(); - ctx.lineTo(x, y); - prevX = truncX; - countX = 0; - minY = maxY = y; - } - lastY = y; - } - drawX(); - } - function _getSegmentMethod(line) { - const opts = line.options; - const borderDash = opts.borderDash && opts.borderDash.length; - const useFastPath = !line._loop && !opts.tension && !opts.stepped && !borderDash; - return useFastPath ? fastPathSegment : pathSegment; - } - function _getInterpolationMethod(options) { - if (options.stepped) { - return _steppedInterpolation; - } - if (options.tension) { - return _bezierInterpolation; - } - return _pointInLine; - } - const LineElement = function (_Element) { - _inheritsLoose(LineElement, _Element); - function LineElement(cfg) { - let _this; - _this = _Element.call(this) || this; - _this.options = undefined; - _this._loop = undefined; - _this._fullLoop = undefined; - _this._points = undefined; - _this._segments = undefined; - _this._pointsUpdated = false; - if (cfg) { - _extends(_assertThisInitialized(_this), cfg); - } - return _this; - } - const _proto = LineElement.prototype; - _proto.updateControlPoints = function updateControlPoints(chartArea) { - const me = this; - const options = me.options; - if (options.tension && !options.stepped && !me._pointsUpdated) { - const loop = options.spanGaps ? me._loop : me._fullLoop; - _updateBezierControlPoints(me._points, options, chartArea, loop); - me._pointsUpdated = true; - } - }; - _proto.first = function first() { - const segments = this.segments; - const points = this.points; - return segments.length && points[segments[0].start]; - } - ; - _proto.last = function last() { - const segments = this.segments; - const points = this.points; - const count = segments.length; - return count && points[segments[count - 1].end]; - } - ; - _proto.interpolate = function interpolate(point, property) { - const me = this; - const options = me.options; - const value = point[property]; - const points = me.points; - const segments = _boundSegments(me, { - property: property, - start: value, - end: value - }); - if (!segments.length) { - return; - } - const result = []; - const _interpolate = _getInterpolationMethod(options); - let i, ilen; - for (i = 0, ilen = segments.length; i < ilen; ++i) { - const _segments$i = segments[i], - start = _segments$i.start, - end = _segments$i.end; - const p1 = points[start]; - const p2 = points[end]; - if (p1 === p2) { - result.push(p1); - continue; - } - const t = Math.abs((value - p1[property]) / (p2[property] - p1[property])); - const interpolated = _interpolate(p1, p2, t, options.stepped); - interpolated[property] = point[property]; - result.push(interpolated); - } - return result.length === 1 ? result[0] : result; - } - ; - _proto.pathSegment = function pathSegment(ctx, segment, params) { - const segmentMethod = _getSegmentMethod(this); - return segmentMethod(ctx, this, segment, params); - } - ; - _proto.path = function path(ctx, start, count) { - const me = this; - const segments = me.segments; - const ilen = segments.length; - const segmentMethod = _getSegmentMethod(me); - let loop = me._loop; - start = start || 0; - count = count || me.points.length - start; - for (let i = 0; i < ilen; ++i) { - loop &= segmentMethod(ctx, me, segments[i], { - start: start, - end: start + count - 1 - }); - } - return !!loop; + prev = point; + } + if (loop) { + point = points[(start + (reverse ? ilen : 0)) % count]; + lineMethod(ctx, prev, point, reverse, options.stepped); + } + return !!loop; +} +function fastPathSegment(ctx, line, segment, params) { + const points = line.points; + const {count, start, ilen} = pathVars(points, segment, params); + const {move = true, reverse} = params || {}; + let avgX = 0; + let countX = 0; + let i, point, prevX, minY, maxY, lastY; + const pointIndex = (index) => (start + (reverse ? ilen - index : index)) % count; + const drawX = () => { + if (minY !== maxY) { + ctx.lineTo(avgX, maxY); + ctx.lineTo(avgX, minY); + ctx.lineTo(avgX, lastY); } - ; - _proto.draw = function draw(ctx, chartArea, start, count) { - const options = this.options || {}; - const points = this.points || []; - if (!points.length || !options.borderWidth) { - return; - } - ctx.save(); - setStyle(ctx, options); - ctx.beginPath(); - if (this.path(ctx, start, count)) { - ctx.closePath(); - } - ctx.stroke(); - ctx.restore(); - this._pointsUpdated = false; - }; - _createClass(LineElement, [{ - key: 'points', - set: function set(points) { - this._points = points; - delete this._segments; - }, - get: function get() { - return this._points; - } - }, { - key: 'segments', - get: function get() { - return this._segments || (this._segments = _computeSegments(this)); - } - }]); - return LineElement; - }(Element$1); - LineElement.id = 'line'; - LineElement.defaults = { - borderCapStyle: 'butt', - borderDash: [], - borderDashOffset: 0, - borderJoinStyle: 'miter', - borderWidth: 3, - capBezierPoints: true, - fill: true, - tension: 0 - }; - LineElement.defaultRoutes = { - backgroundColor: 'color', - borderColor: 'color' }; - - const PointElement = function (_Element) { - _inheritsLoose(PointElement, _Element); - function PointElement(cfg) { - let _this; - _this = _Element.call(this) || this; - _this.options = undefined; - _this.skip = undefined; - _this.stop = undefined; - if (cfg) { - _extends(_assertThisInitialized(_this), cfg); - } - return _this; - } - const _proto = PointElement.prototype; - _proto.inRange = function inRange(mouseX, mouseY, useFinalPosition) { - const options = this.options; - const _this$getProps = this.getProps(['x', 'y'], useFinalPosition), - x = _this$getProps.x, - y = _this$getProps.y; - return Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2) < Math.pow(options.hitRadius + options.radius, 2); - }; - _proto.inXRange = function inXRange(mouseX, useFinalPosition) { - const options = this.options; - const _this$getProps2 = this.getProps(['x'], useFinalPosition), - x = _this$getProps2.x; - return Math.abs(mouseX - x) < options.radius + options.hitRadius; - }; - _proto.inYRange = function inYRange(mouseY, useFinalPosition) { - const options = this.options; - const _this$getProps3 = this.getProps(['x'], useFinalPosition), - y = _this$getProps3.y; - return Math.abs(mouseY - y) < options.radius + options.hitRadius; - }; - _proto.getCenterPoint = function getCenterPoint(useFinalPosition) { - const _this$getProps4 = this.getProps(['x', 'y'], useFinalPosition), - x = _this$getProps4.x, - y = _this$getProps4.y; - return { - x: x, - y: y - }; - }; - _proto.size = function size() { - const options = this.options || {}; - const radius = Math.max(options.radius, options.hoverRadius) || 0; - const borderWidth = radius && options.borderWidth || 0; - return (radius + borderWidth) * 2; - }; - _proto.draw = function draw(ctx) { - const me = this; - const options = me.options; - if (me.skip || options.radius <= 0) { - return; - } - ctx.strokeStyle = options.borderColor; - ctx.lineWidth = options.borderWidth; - ctx.fillStyle = options.backgroundColor; - drawPoint(ctx, options, me.x, me.y); - }; - _proto.getRange = function getRange() { - const options = this.options || {}; - return options.radius + options.hitRadius; - }; - return PointElement; - }(Element$1); - PointElement.id = 'point'; - PointElement.defaults = { - borderWidth: 1, - hitRadius: 1, - hoverBorderWidth: 1, - hoverRadius: 4, - pointStyle: 'circle', - radius: 3 - }; - PointElement.defaultRoutes = { - backgroundColor: 'color', - borderColor: 'color' - }; - - function getBarBounds(bar, useFinalPosition) { - const _bar$getProps = bar.getProps(['x', 'y', 'base', 'width', 'height'], useFinalPosition), - x = _bar$getProps.x, - y = _bar$getProps.y, - base = _bar$getProps.base, - width = _bar$getProps.width, - height = _bar$getProps.height; - let left, right, top, bottom, half; - if (bar.horizontal) { - half = height / 2; - left = Math.min(x, base); - right = Math.max(x, base); - top = y - half; - bottom = y + half; + if (move) { + point = points[pointIndex(0)]; + ctx.moveTo(point.x, point.y); + } + for (i = 0; i <= ilen; ++i) { + point = points[pointIndex(i)]; + if (point.skip) { + continue; + } + const x = point.x; + const y = point.y; + const truncX = x | 0; + if (truncX === prevX) { + if (y < minY) { + minY = y; + } else if (y > maxY) { + maxY = y; + } + avgX = (countX * avgX + x) / ++countX; } else { - half = width / 2; - left = x - half; - right = x + half; - top = Math.min(y, base); - bottom = Math.max(y, base); + drawX(); + ctx.lineTo(x, y); + prevX = truncX; + countX = 0; + minY = maxY = y; + } + lastY = y; + } + drawX(); +} +function _getSegmentMethod(line) { + const opts = line.options; + const borderDash = opts.borderDash && opts.borderDash.length; + const useFastPath = !line._decimated && !line._loop && !opts.tension && opts.cubicInterpolationMode !== 'monotone' && !opts.stepped && !borderDash; + return useFastPath ? fastPathSegment : pathSegment; +} +function _getInterpolationMethod(options) { + if (options.stepped) { + return _steppedInterpolation; + } + if (options.tension || options.cubicInterpolationMode === 'monotone') { + return _bezierInterpolation; + } + return _pointInLine; +} +function strokePathWithCache(ctx, line, start, count) { + let path = line._path; + if (!path) { + path = line._path = new Path2D(); + if (line.path(path, start, count)) { + path.closePath(); + } + } + setStyle(ctx, line.options); + ctx.stroke(path); +} +function strokePathDirect(ctx, line, start, count) { + const {segments, options} = line; + const segmentMethod = _getSegmentMethod(line); + for (const segment of segments) { + setStyle(ctx, options, segment.style); + ctx.beginPath(); + if (segmentMethod(ctx, line, segment, {start, end: start + count - 1})) { + ctx.closePath(); } - return { - left: left, - top: top, - right: right, - bottom: bottom - }; + ctx.stroke(); } - function parseBorderSkipped(bar) { - let edge = bar.options.borderSkipped; - const res = {}; - if (!edge) { - return res; +} +const usePath2D = typeof Path2D === 'function'; +function draw(ctx, line, start, count) { + if (usePath2D && !line.options.segment) { + strokePathWithCache(ctx, line, start, count); + } else { + strokePathDirect(ctx, line, start, count); + } +} +class LineElement extends Element { + constructor(cfg) { + super(); + this.animated = true; + this.options = undefined; + this._chart = undefined; + this._loop = undefined; + this._fullLoop = undefined; + this._path = undefined; + this._points = undefined; + this._segments = undefined; + this._decimated = false; + this._pointsUpdated = false; + this._datasetIndex = undefined; + if (cfg) { + Object.assign(this, cfg); + } + } + updateControlPoints(chartArea, indexAxis) { + const options = this.options; + if ((options.tension || options.cubicInterpolationMode === 'monotone') && !options.stepped && !this._pointsUpdated) { + const loop = options.spanGaps ? this._loop : this._fullLoop; + _updateBezierControlPoints(this._points, options, chartArea, loop, indexAxis); + this._pointsUpdated = true; + } + } + set points(points) { + this._points = points; + delete this._segments; + delete this._path; + this._pointsUpdated = false; + } + get points() { + return this._points; + } + get segments() { + return this._segments || (this._segments = _computeSegments(this, this.options.segment)); + } + first() { + const segments = this.segments; + const points = this.points; + return segments.length && points[segments[0].start]; + } + last() { + const segments = this.segments; + const points = this.points; + const count = segments.length; + return count && points[segments[count - 1].end]; + } + interpolate(point, property) { + const options = this.options; + const value = point[property]; + const points = this.points; + const segments = _boundSegments(this, {property, start: value, end: value}); + if (!segments.length) { + return; } - edge = bar.horizontal ? parseEdge(edge, 'left', 'right', bar.base > bar.x) : parseEdge(edge, 'bottom', 'top', bar.base < bar.y); - res[edge] = true; - return res; - } - function parseEdge(edge, a, b, reverse) { - if (reverse) { - edge = swap(edge, a, b); - edge = startEnd(edge, b, a); - } else { - edge = startEnd(edge, a, b); + const result = []; + const _interpolate = _getInterpolationMethod(options); + let i, ilen; + for (i = 0, ilen = segments.length; i < ilen; ++i) { + const {start, end} = segments[i]; + const p1 = points[start]; + const p2 = points[end]; + if (p1 === p2) { + result.push(p1); + continue; + } + const t = Math.abs((value - p1[property]) / (p2[property] - p1[property])); + const interpolated = _interpolate(p1, p2, t, options.stepped); + interpolated[property] = point[property]; + result.push(interpolated); } - return edge; + return result.length === 1 ? result[0] : result; } - function swap(orig, v1, v2) { - return orig === v1 ? v2 : orig === v2 ? v1 : orig; + pathSegment(ctx, segment, params) { + const segmentMethod = _getSegmentMethod(this); + return segmentMethod(ctx, this, segment, params); } - function startEnd(v, start, end) { - return v === 'start' ? start : v === 'end' ? end : v; + path(ctx, start, count) { + const segments = this.segments; + const segmentMethod = _getSegmentMethod(this); + let loop = this._loop; + start = start || 0; + count = count || (this.points.length - start); + for (const segment of segments) { + loop &= segmentMethod(ctx, this, segment, {start, end: start + count - 1}); + } + return !!loop; + } + draw(ctx, chartArea, start, count) { + const options = this.options || {}; + const points = this.points || []; + if (points.length && options.borderWidth) { + ctx.save(); + draw(ctx, this, start, count); + ctx.restore(); + } + if (this.animated) { + this._pointsUpdated = false; + this._path = undefined; + } + } +} +LineElement.id = 'line'; +LineElement.defaults = { + borderCapStyle: 'butt', + borderDash: [], + borderDashOffset: 0, + borderJoinStyle: 'miter', + borderWidth: 3, + capBezierPoints: true, + cubicInterpolationMode: 'default', + fill: false, + spanGaps: false, + stepped: false, + tension: 0, +}; +LineElement.defaultRoutes = { + backgroundColor: 'backgroundColor', + borderColor: 'borderColor' +}; +LineElement.descriptors = { + _scriptable: true, + _indexable: (name) => name !== 'borderDash' && name !== 'fill', +}; + +function inRange$1(el, pos, axis, useFinalPosition) { + const options = el.options; + const {[axis]: value} = el.getProps([axis], useFinalPosition); + return (Math.abs(pos - value) < options.radius + options.hitRadius); +} +class PointElement extends Element { + constructor(cfg) { + super(); + this.options = undefined; + this.parsed = undefined; + this.skip = undefined; + this.stop = undefined; + if (cfg) { + Object.assign(this, cfg); + } + } + inRange(mouseX, mouseY, useFinalPosition) { + const options = this.options; + const {x, y} = this.getProps(['x', 'y'], useFinalPosition); + return ((Math.pow(mouseX - x, 2) + Math.pow(mouseY - y, 2)) < Math.pow(options.hitRadius + options.radius, 2)); + } + inXRange(mouseX, useFinalPosition) { + return inRange$1(this, mouseX, 'x', useFinalPosition); + } + inYRange(mouseY, useFinalPosition) { + return inRange$1(this, mouseY, 'y', useFinalPosition); + } + getCenterPoint(useFinalPosition) { + const {x, y} = this.getProps(['x', 'y'], useFinalPosition); + return {x, y}; + } + size(options) { + options = options || this.options || {}; + let radius = options.radius || 0; + radius = Math.max(radius, radius && options.hoverRadius || 0); + const borderWidth = radius && options.borderWidth || 0; + return (radius + borderWidth) * 2; + } + draw(ctx, area) { + const options = this.options; + if (this.skip || options.radius < 0.1 || !_isPointInArea(this, area, this.size(options) / 2)) { + return; + } + ctx.strokeStyle = options.borderColor; + ctx.lineWidth = options.borderWidth; + ctx.fillStyle = options.backgroundColor; + drawPoint(ctx, options, this.x, this.y); + } + getRange() { + const options = this.options || {}; + return options.radius + options.hitRadius; + } +} +PointElement.id = 'point'; +PointElement.defaults = { + borderWidth: 1, + hitRadius: 1, + hoverBorderWidth: 1, + hoverRadius: 4, + pointStyle: 'circle', + radius: 3, + rotation: 0 +}; +PointElement.defaultRoutes = { + backgroundColor: 'backgroundColor', + borderColor: 'borderColor' +}; + +function getBarBounds(bar, useFinalPosition) { + const {x, y, base, width, height} = bar.getProps(['x', 'y', 'base', 'width', 'height'], useFinalPosition); + let left, right, top, bottom, half; + if (bar.horizontal) { + half = height / 2; + left = Math.min(x, base); + right = Math.max(x, base); + top = y - half; + bottom = y + half; + } else { + half = width / 2; + left = x - half; + right = x + half; + top = Math.min(y, base); + bottom = Math.max(y, base); + } + return {left, top, right, bottom}; +} +function skipOrLimit(skip, value, min, max) { + return skip ? 0 : _limitValue(value, min, max); +} +function parseBorderWidth(bar, maxW, maxH) { + const value = bar.options.borderWidth; + const skip = bar.borderSkipped; + const o = toTRBL(value); + return { + t: skipOrLimit(skip.top, o.top, 0, maxH), + r: skipOrLimit(skip.right, o.right, 0, maxW), + b: skipOrLimit(skip.bottom, o.bottom, 0, maxH), + l: skipOrLimit(skip.left, o.left, 0, maxW) + }; +} +function parseBorderRadius(bar, maxW, maxH) { + const {enableBorderRadius} = bar.getProps(['enableBorderRadius']); + const value = bar.options.borderRadius; + const o = toTRBLCorners(value); + const maxR = Math.min(maxW, maxH); + const skip = bar.borderSkipped; + const enableBorder = enableBorderRadius || isObject(value); + return { + topLeft: skipOrLimit(!enableBorder || skip.top || skip.left, o.topLeft, 0, maxR), + topRight: skipOrLimit(!enableBorder || skip.top || skip.right, o.topRight, 0, maxR), + bottomLeft: skipOrLimit(!enableBorder || skip.bottom || skip.left, o.bottomLeft, 0, maxR), + bottomRight: skipOrLimit(!enableBorder || skip.bottom || skip.right, o.bottomRight, 0, maxR) + }; +} +function boundingRects(bar) { + const bounds = getBarBounds(bar); + const width = bounds.right - bounds.left; + const height = bounds.bottom - bounds.top; + const border = parseBorderWidth(bar, width / 2, height / 2); + const radius = parseBorderRadius(bar, width / 2, height / 2); + return { + outer: { + x: bounds.left, + y: bounds.top, + w: width, + h: height, + radius + }, + inner: { + x: bounds.left + border.l, + y: bounds.top + border.t, + w: width - border.l - border.r, + h: height - border.t - border.b, + radius: { + topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)), + topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)), + bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)), + bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r)), + } + } + }; +} +function inRange(bar, x, y, useFinalPosition) { + const skipX = x === null; + const skipY = y === null; + const skipBoth = skipX && skipY; + const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition); + return bounds + && (skipX || _isBetween(x, bounds.left, bounds.right)) + && (skipY || _isBetween(y, bounds.top, bounds.bottom)); +} +function hasRadius(radius) { + return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight; +} +function addNormalRectPath(ctx, rect) { + ctx.rect(rect.x, rect.y, rect.w, rect.h); +} +function inflateRect(rect, amount, refRect = {}) { + const x = rect.x !== refRect.x ? -amount : 0; + const y = rect.y !== refRect.y ? -amount : 0; + const w = (rect.x + rect.w !== refRect.x + refRect.w ? amount : 0) - x; + const h = (rect.y + rect.h !== refRect.y + refRect.h ? amount : 0) - y; + return { + x: rect.x + x, + y: rect.y + y, + w: rect.w + w, + h: rect.h + h, + radius: rect.radius + }; +} +class BarElement extends Element { + constructor(cfg) { + super(); + this.options = undefined; + this.horizontal = undefined; + this.base = undefined; + this.width = undefined; + this.height = undefined; + this.inflateAmount = undefined; + if (cfg) { + Object.assign(this, cfg); + } + } + draw(ctx) { + const {inflateAmount, options: {borderColor, backgroundColor}} = this; + const {inner, outer} = boundingRects(this); + const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath; + ctx.save(); + if (outer.w !== inner.w || outer.h !== inner.h) { + ctx.beginPath(); + addRectPath(ctx, inflateRect(outer, inflateAmount, inner)); + ctx.clip(); + addRectPath(ctx, inflateRect(inner, -inflateAmount, outer)); + ctx.fillStyle = borderColor; + ctx.fill('evenodd'); + } + ctx.beginPath(); + addRectPath(ctx, inflateRect(inner, inflateAmount)); + ctx.fillStyle = backgroundColor; + ctx.fill(); + ctx.restore(); } - function skipOrLimit(skip, value, min, max) { - return skip ? 0 : Math.max(Math.min(value, max), min); + inRange(mouseX, mouseY, useFinalPosition) { + return inRange(this, mouseX, mouseY, useFinalPosition); } - function parseBorderWidth(bar, maxW, maxH) { - const value = bar.options.borderWidth; - const skip = parseBorderSkipped(bar); - const o = toTRBL(value); - return { - t: skipOrLimit(skip.top, o.top, 0, maxH), - r: skipOrLimit(skip.right, o.right, 0, maxW), - b: skipOrLimit(skip.bottom, o.bottom, 0, maxH), - l: skipOrLimit(skip.left, o.left, 0, maxW) - }; + inXRange(mouseX, useFinalPosition) { + return inRange(this, mouseX, null, useFinalPosition); } - function parseBorderRadius(bar, maxW, maxH) { - const value = bar.options.borderRadius; - const o = toTRBLCorners(value); - const maxR = Math.min(maxW, maxH); - const skip = parseBorderSkipped(bar); - return { - topLeft: skipOrLimit(skip.top || skip.left, o.topLeft, 0, maxR), - topRight: skipOrLimit(skip.top || skip.right, o.topRight, 0, maxR), - bottomLeft: skipOrLimit(skip.bottom || skip.left, o.bottomLeft, 0, maxR), - bottomRight: skipOrLimit(skip.bottom || skip.right, o.bottomRight, 0, maxR) - }; + inYRange(mouseY, useFinalPosition) { + return inRange(this, null, mouseY, useFinalPosition); } - function boundingRects(bar) { - const bounds = getBarBounds(bar); - const width = bounds.right - bounds.left; - const height = bounds.bottom - bounds.top; - const border = parseBorderWidth(bar, width / 2, height / 2); - const radius = parseBorderRadius(bar, width / 2, height / 2); + getCenterPoint(useFinalPosition) { + const {x, y, base, horizontal} = this.getProps(['x', 'y', 'base', 'horizontal'], useFinalPosition); return { - outer: { - x: bounds.left, - y: bounds.top, - w: width, - h: height, - radius: radius - }, - inner: { - x: bounds.left + border.l, - y: bounds.top + border.t, - w: width - border.l - border.r, - h: height - border.t - border.b, - radius: { - topLeft: Math.max(0, radius.topLeft - Math.max(border.t, border.l)), - topRight: Math.max(0, radius.topRight - Math.max(border.t, border.r)), - bottomLeft: Math.max(0, radius.bottomLeft - Math.max(border.b, border.l)), - bottomRight: Math.max(0, radius.bottomRight - Math.max(border.b, border.r)) + x: horizontal ? (x + base) / 2 : x, + y: horizontal ? y : (y + base) / 2 + }; + } + getRange(axis) { + return axis === 'x' ? this.width / 2 : this.height / 2; + } +} +BarElement.id = 'bar'; +BarElement.defaults = { + borderSkipped: 'start', + borderWidth: 0, + borderRadius: 0, + inflateAmount: 'auto', + pointStyle: undefined +}; +BarElement.defaultRoutes = { + backgroundColor: 'backgroundColor', + borderColor: 'borderColor' +}; + +var elements = /*#__PURE__*/Object.freeze({ +__proto__: null, +ArcElement: ArcElement, +LineElement: LineElement, +PointElement: PointElement, +BarElement: BarElement +}); + +function lttbDecimation(data, start, count, availableWidth, options) { + const samples = options.samples || availableWidth; + if (samples >= count) { + return data.slice(start, start + count); + } + const decimated = []; + const bucketWidth = (count - 2) / (samples - 2); + let sampledIndex = 0; + const endIndex = start + count - 1; + let a = start; + let i, maxAreaPoint, maxArea, area, nextA; + decimated[sampledIndex++] = data[a]; + for (i = 0; i < samples - 2; i++) { + let avgX = 0; + let avgY = 0; + let j; + const avgRangeStart = Math.floor((i + 1) * bucketWidth) + 1 + start; + const avgRangeEnd = Math.min(Math.floor((i + 2) * bucketWidth) + 1, count) + start; + const avgRangeLength = avgRangeEnd - avgRangeStart; + for (j = avgRangeStart; j < avgRangeEnd; j++) { + avgX += data[j].x; + avgY += data[j].y; + } + avgX /= avgRangeLength; + avgY /= avgRangeLength; + const rangeOffs = Math.floor(i * bucketWidth) + 1 + start; + const rangeTo = Math.min(Math.floor((i + 1) * bucketWidth) + 1, count) + start; + const {x: pointAx, y: pointAy} = data[a]; + maxArea = area = -1; + for (j = rangeOffs; j < rangeTo; j++) { + area = 0.5 * Math.abs( + (pointAx - avgX) * (data[j].y - pointAy) - + (pointAx - data[j].x) * (avgY - pointAy) + ); + if (area > maxArea) { + maxArea = area; + maxAreaPoint = data[j]; + nextA = j; + } + } + decimated[sampledIndex++] = maxAreaPoint; + a = nextA; + } + decimated[sampledIndex++] = data[endIndex]; + return decimated; +} +function minMaxDecimation(data, start, count, availableWidth) { + let avgX = 0; + let countX = 0; + let i, point, x, y, prevX, minIndex, maxIndex, startIndex, minY, maxY; + const decimated = []; + const endIndex = start + count - 1; + const xMin = data[start].x; + const xMax = data[endIndex].x; + const dx = xMax - xMin; + for (i = start; i < start + count; ++i) { + point = data[i]; + x = (point.x - xMin) / dx * availableWidth; + y = point.y; + const truncX = x | 0; + if (truncX === prevX) { + if (y < minY) { + minY = y; + minIndex = i; + } else if (y > maxY) { + maxY = y; + maxIndex = i; + } + avgX = (countX * avgX + point.x) / ++countX; + } else { + const lastIndex = i - 1; + if (!isNullOrUndef(minIndex) && !isNullOrUndef(maxIndex)) { + const intermediateIndex1 = Math.min(minIndex, maxIndex); + const intermediateIndex2 = Math.max(minIndex, maxIndex); + if (intermediateIndex1 !== startIndex && intermediateIndex1 !== lastIndex) { + decimated.push({ + ...data[intermediateIndex1], + x: avgX, + }); + } + if (intermediateIndex2 !== startIndex && intermediateIndex2 !== lastIndex) { + decimated.push({ + ...data[intermediateIndex2], + x: avgX + }); } } - }; - } - function _inRange(bar, x, y, useFinalPosition) { - const skipX = x === null; - const skipY = y === null; - const skipBoth = skipX && skipY; - const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition); - return bounds && (skipX || x >= bounds.left && x <= bounds.right) && (skipY || y >= bounds.top && y <= bounds.bottom); - } - function hasRadius(radius) { - return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight; - } - function addRoundedRectPath(ctx, rect) { - const x = rect.x, - y = rect.y, - w = rect.w, - h = rect.h, - radius = rect.radius; - ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, -HALF_PI, PI, true); - ctx.lineTo(x, y + h - radius.bottomLeft); - ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true); - ctx.lineTo(x + w - radius.bottomRight, y + h); - ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true); - ctx.lineTo(x + w, y + radius.topRight); - ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true); - ctx.lineTo(x + radius.topLeft, y); - } - function addNormalRectPath(ctx, rect) { - ctx.rect(rect.x, rect.y, rect.w, rect.h); - } - const BarElement = function (_Element) { - _inheritsLoose(BarElement, _Element); - function BarElement(cfg) { - let _this; - _this = _Element.call(this) || this; - _this.options = undefined; - _this.horizontal = undefined; - _this.base = undefined; - _this.width = undefined; - _this.height = undefined; - if (cfg) { - _extends(_assertThisInitialized(_this), cfg); - } - return _this; - } - const _proto = BarElement.prototype; - _proto.draw = function draw(ctx) { - const options = this.options; - const _boundingRects = boundingRects(this), - inner = _boundingRects.inner, - outer = _boundingRects.outer; - const addRectPath = hasRadius(outer.radius) ? addRoundedRectPath : addNormalRectPath; - ctx.save(); - if (outer.w !== inner.w || outer.h !== inner.h) { - ctx.beginPath(); - addRectPath(ctx, outer); - ctx.clip(); - addRectPath(ctx, inner); - ctx.fillStyle = options.borderColor; - ctx.fill('evenodd'); + if (i > 0 && lastIndex !== startIndex) { + decimated.push(data[lastIndex]); } - ctx.beginPath(); - addRectPath(ctx, inner); - ctx.fillStyle = options.backgroundColor; - ctx.fill(); - ctx.restore(); - }; - _proto.inRange = function inRange(mouseX, mouseY, useFinalPosition) { - return _inRange(this, mouseX, mouseY, useFinalPosition); - }; - _proto.inXRange = function inXRange(mouseX, useFinalPosition) { - return _inRange(this, mouseX, null, useFinalPosition); - }; - _proto.inYRange = function inYRange(mouseY, useFinalPosition) { - return _inRange(this, null, mouseY, useFinalPosition); - }; - _proto.getCenterPoint = function getCenterPoint(useFinalPosition) { - const _this$getProps = this.getProps(['x', 'y', 'base', 'horizontal'], useFinalPosition), - x = _this$getProps.x, - y = _this$getProps.y, - base = _this$getProps.base, - horizontal = _this$getProps.horizontal; - return { - x: horizontal ? (x + base) / 2 : x, - y: horizontal ? y : (y + base) / 2 - }; - }; - _proto.getRange = function getRange(axis) { - return axis === 'x' ? this.width / 2 : this.height / 2; - }; - return BarElement; - }(Element$1); - BarElement.id = 'bar'; - BarElement.defaults = { - borderSkipped: 'start', - borderWidth: 0, - borderRadius: 0 - }; - BarElement.defaultRoutes = { - backgroundColor: 'color', - borderColor: 'color' - }; - - const elements = /*#__PURE__*/Object.freeze({ - __proto__: null, - ArcElement: ArcElement, - LineElement: LineElement, - PointElement: PointElement, - BarElement: BarElement - }); - - function getLineByIndex(chart, index) { - const meta = chart.getDatasetMeta(index); - const visible = meta && chart.isDatasetVisible(index); - return visible ? meta.dataset : null; - } - function parseFillOption(line) { - const options = line.options; - const fillOption = options.fill; - let fill = valueOrDefault(fillOption && fillOption.target, fillOption); - if (fill === undefined) { - fill = !!options.backgroundColor; - } - if (fill === false || fill === null) { - return false; - } - if (fill === true) { - return 'origin'; + decimated.push(point); + prevX = truncX; + countX = 0; + minY = maxY = y; + minIndex = maxIndex = startIndex = i; } - return fill; } - function decodeFill(line, index, count) { - const fill = parseFillOption(line); - if (isObject(fill)) { - return isNaN(fill.value) ? false : fill; + return decimated; +} +function cleanDecimatedDataset(dataset) { + if (dataset._decimated) { + const data = dataset._data; + delete dataset._decimated; + delete dataset._data; + Object.defineProperty(dataset, 'data', {value: data}); + } +} +function cleanDecimatedData(chart) { + chart.data.datasets.forEach((dataset) => { + cleanDecimatedDataset(dataset); + }); +} +function getStartAndCountOfVisiblePointsSimplified(meta, points) { + const pointCount = points.length; + let start = 0; + let count; + const {iScale} = meta; + const {min, max, minDefined, maxDefined} = iScale.getUserBounds(); + if (minDefined) { + start = _limitValue(_lookupByKey(points, iScale.axis, min).lo, 0, pointCount - 1); + } + if (maxDefined) { + count = _limitValue(_lookupByKey(points, iScale.axis, max).hi + 1, start, pointCount) - start; + } else { + count = pointCount - start; + } + return {start, count}; +} +var plugin_decimation = { + id: 'decimation', + defaults: { + algorithm: 'min-max', + enabled: false, + }, + beforeElementsUpdate: (chart, args, options) => { + if (!options.enabled) { + cleanDecimatedData(chart); + return; } - let target = parseFloat(fill); - if (isNumberFinite(target) && Math.floor(target) === target) { - if (fill[0] === '-' || fill[0] === '+') { - target = index + target; + const availableWidth = chart.width; + chart.data.datasets.forEach((dataset, datasetIndex) => { + const {_data, indexAxis} = dataset; + const meta = chart.getDatasetMeta(datasetIndex); + const data = _data || dataset.data; + if (resolve([indexAxis, chart.options.indexAxis]) === 'y') { + return; } - if (target === index || target < 0 || target >= count) { - return false; + if (!meta.controller.supportsDecimation) { + return; } - return target; - } - return ['origin', 'start', 'end', 'stack'].indexOf(fill) >= 0 && fill; - } - function computeLinearBoundary(source) { - const _source$scale = source.scale, - scale = _source$scale === void 0 ? {} : _source$scale, - fill = source.fill; - let target = null; - let horizontal; - if (fill === 'start') { - target = scale.bottom; - } else if (fill === 'end') { - target = scale.top; - } else if (isObject(fill)) { - target = scale.getPixelForValue(fill.value); - } else if (scale.getBasePixel) { - target = scale.getBasePixel(); - } - if (isNumberFinite(target)) { - horizontal = scale.isHorizontal(); - return { - x: horizontal ? target : null, - y: horizontal ? null : target - }; - } - return null; - } - const simpleArc = function () { - function simpleArc(opts) { - this.x = opts.x; - this.y = opts.y; - this.radius = opts.radius; - } - const _proto = simpleArc.prototype; - _proto.pathSegment = function pathSegment(ctx, bounds, opts) { - const x = this.x, - y = this.y, - radius = this.radius; - bounds = bounds || { - start: 0, - end: TAU - }; - if (opts.reverse) { - ctx.arc(x, y, radius, bounds.end, bounds.start, true); - } else { - ctx.arc(x, y, radius, bounds.start, bounds.end); + const xAxis = chart.scales[meta.xAxisID]; + if (xAxis.type !== 'linear' && xAxis.type !== 'time') { + return; } - return !opts.bounds; - }; - _proto.interpolate = function interpolate(point, property) { - const x = this.x, - y = this.y, - radius = this.radius; - const angle = point.angle; - if (property === 'angle') { - return { - x: x + Math.cos(angle) * radius, - y: y + Math.sin(angle) * radius, - angle: angle - }; + if (chart.options.parsing) { + return; } - }; - return simpleArc; - }(); - function computeCircularBoundary(source) { - const scale = source.scale, - fill = source.fill; - const options = scale.options; - const length = scale.getLabels().length; - const target = []; - const start = options.reverse ? scale.max : scale.min; - const end = options.reverse ? scale.min : scale.max; - let i, center, value; - if (fill === 'start') { - value = start; - } else if (fill === 'end') { - value = end; - } else if (isObject(fill)) { - value = fill.value; - } else { - value = scale.getBaseValue(); - } - if (options.gridLines.circular) { - center = scale.getPointPositionForValue(0, start); - return new simpleArc({ - x: center.x, - y: center.y, - radius: scale.getDistanceFromCenterForValue(value) - }); - } - for (i = 0; i < length; ++i) { - target.push(scale.getPointPositionForValue(i, value)); - } - return target; - } - function computeBoundary(source) { - const scale = source.scale || {}; - if (scale.getPointPositionForValue) { - return computeCircularBoundary(source); - } - return computeLinearBoundary(source); - } - function pointsFromSegments(boundary, line) { - const _ref = boundary || {}, - _ref$x = _ref.x, - x = _ref$x === void 0 ? null : _ref$x, - _ref$y = _ref.y, - y = _ref$y === void 0 ? null : _ref$y; - const linePoints = line.points; - const points = []; - line.segments.forEach(function (segment) { - const first = linePoints[segment.start]; - const last = linePoints[segment.end]; - if (y !== null) { - points.push({ - x: first.x, - y: y - }); - points.push({ - x: last.x, - y: y - }); - } else if (x !== null) { - points.push({ - x: x, - y: first.y - }); - points.push({ - x: x, - y: last.y + let {start, count} = getStartAndCountOfVisiblePointsSimplified(meta, data); + const threshold = options.threshold || 4 * availableWidth; + if (count <= threshold) { + cleanDecimatedDataset(dataset); + return; + } + if (isNullOrUndef(_data)) { + dataset._data = data; + delete dataset.data; + Object.defineProperty(dataset, 'data', { + configurable: true, + enumerable: true, + get: function() { + return this._decimated; + }, + set: function(d) { + this._data = d; + } }); } - }); - return points; - } - function buildStackLine(source) { - const chart = source.chart, - scale = source.scale, - index = source.index, - line = source.line; - const points = []; - const segments = line.segments; - const sourcePoints = line.points; - const linesBelow = getLinesBelow(chart, index); - linesBelow.push(createBoundaryLine({ - x: null, - y: scale.bottom - }, line)); - for (let i = 0; i < segments.length; i++) { - const segment = segments[i]; - for (let j = segment.start; j <= segment.end; j++) { - addPointsBelow(points, sourcePoints[j], linesBelow); - } - } - return new LineElement({ - points: points, - options: {} - }); - } - const isLineAndNotInHideAnimation = function isLineAndNotInHideAnimation(meta) { - return meta.type === 'line' && !meta.hidden; - }; - function getLinesBelow(chart, index) { - const below = []; - const metas = chart.getSortedVisibleDatasetMetas(); - for (let i = 0; i < metas.length; i++) { - const meta = metas[i]; - if (meta.index === index) { + let decimated; + switch (options.algorithm) { + case 'lttb': + decimated = lttbDecimation(data, start, count, availableWidth, options); break; + case 'min-max': + decimated = minMaxDecimation(data, start, count, availableWidth); + break; + default: + throw new Error(`Unsupported decimation algorithm '${options.algorithm}'`); } - if (isLineAndNotInHideAnimation(meta)) { - below.unshift(meta.dataset); - } - } - return below; + dataset._decimated = decimated; + }); + }, + destroy(chart) { + cleanDecimatedData(chart); } - function addPointsBelow(points, sourcePoint, linesBelow) { - const postponed = []; - for (let j = 0; j < linesBelow.length; j++) { - const line = linesBelow[j]; - const _findPoint = findPoint(line, sourcePoint, 'x'), - first = _findPoint.first, - last = _findPoint.last, - point = _findPoint.point; - if (!point || first && last) { - continue; - } - if (first) { - postponed.unshift(point); - } else { - points.push(point); - if (!last) { - break; - } - } +}; + +function _segments(line, target, property) { + const segments = line.segments; + const points = line.points; + const tpoints = target.points; + const parts = []; + for (const segment of segments) { + let {start, end} = segment; + end = _findSegmentEnd(start, end, points); + const bounds = _getBounds(property, points[start], points[end], segment.loop); + if (!target.segments) { + parts.push({ + source: segment, + target: bounds, + start: points[start], + end: points[end] + }); + continue; } - points.push.apply(points, postponed); - } - function findPoint(line, sourcePoint, property) { - const point = line.interpolate(sourcePoint, property); - if (!point) { - return {}; - } - const pointValue = point[property]; - const segments = line.segments; - const linePoints = line.points; - let first = false; - let last = false; - for (let i = 0; i < segments.length; i++) { - const segment = segments[i]; - const firstValue = linePoints[segment.start][property]; - const lastValue = linePoints[segment.end][property]; - if (pointValue >= firstValue && pointValue <= lastValue) { - first = pointValue === firstValue; - last = pointValue === lastValue; - break; + const targetSegments = _boundSegments(target, bounds); + for (const tgt of targetSegments) { + const subBounds = _getBounds(property, tpoints[tgt.start], tpoints[tgt.end], tgt.loop); + const fillSources = _boundSegment(segment, points, subBounds); + for (const fillSource of fillSources) { + parts.push({ + source: fillSource, + target: tgt, + start: { + [property]: _getEdge(bounds, subBounds, 'start', Math.max) + }, + end: { + [property]: _getEdge(bounds, subBounds, 'end', Math.min) + } + }); } } - return { - first: first, - last: last, - point: point - }; } - function getTarget(source) { - const chart = source.chart, - fill = source.fill, - line = source.line; - if (isNumberFinite(fill)) { - return getLineByIndex(chart, fill); + return parts; +} +function _getBounds(property, first, last, loop) { + if (loop) { + return; + } + let start = first[property]; + let end = last[property]; + if (property === 'angle') { + start = _normalizeAngle(start); + end = _normalizeAngle(end); + } + return {property, start, end}; +} +function _pointsFromSegments(boundary, line) { + const {x = null, y = null} = boundary || {}; + const linePoints = line.points; + const points = []; + line.segments.forEach(({start, end}) => { + end = _findSegmentEnd(start, end, linePoints); + const first = linePoints[start]; + const last = linePoints[end]; + if (y !== null) { + points.push({x: first.x, y}); + points.push({x: last.x, y}); + } else if (x !== null) { + points.push({x, y: first.y}); + points.push({x, y: last.y}); } - if (fill === 'stack') { - return buildStackLine(source); - } - const boundary = computeBoundary(source); - if (boundary instanceof simpleArc) { - return boundary; - } - return createBoundaryLine(boundary, line); + }); + return points; +} +function _findSegmentEnd(start, end, points) { + for (;end > start; end--) { + const point = points[end]; + if (!isNaN(point.x) && !isNaN(point.y)) { + break; + } + } + return end; +} +function _getEdge(a, b, prop, fn) { + if (a && b) { + return fn(a[prop], b[prop]); + } + return a ? a[prop] : b ? b[prop] : 0; +} + +function _createBoundaryLine(boundary, line) { + let points = []; + let _loop = false; + if (isArray(boundary)) { + _loop = true; + points = boundary; + } else { + points = _pointsFromSegments(boundary, line); + } + return points.length ? new LineElement({ + points, + options: {tension: 0}, + _loop, + _fullLoop: _loop + }) : null; +} +function _shouldApplyFill(source) { + return source && source.fill !== false; +} + +function _resolveTarget(sources, index, propagate) { + const source = sources[index]; + let fill = source.fill; + const visited = [index]; + let target; + if (!propagate) { + return fill; } - function createBoundaryLine(boundary, line) { - let points = []; - let _loop = false; - if (isArray(boundary)) { - _loop = true; - points = boundary; - } else { - points = pointsFromSegments(boundary, line); - } - return points.length ? new LineElement({ - points: points, - options: { - tension: 0 - }, - _loop: _loop, - _fullLoop: _loop - }) : null; - } - function resolveTarget(sources, index, propagate) { - const source = sources[index]; - let fill = source.fill; - const visited = [index]; - let target; - if (!propagate) { + while (fill !== false && visited.indexOf(fill) === -1) { + if (!isNumberFinite(fill)) { return fill; } - while (fill !== false && visited.indexOf(fill) === -1) { - if (!isNumberFinite(fill)) { - return fill; - } - target = sources[fill]; - if (!target) { - return false; - } - if (target.visible) { - return fill; - } - visited.push(fill); - fill = target.fill; + target = sources[fill]; + if (!target) { + return false; + } + if (target.visible) { + return fill; } + visited.push(fill); + fill = target.fill; + } + return false; +} +function _decodeFill(line, index, count) { + const fill = parseFillOption(line); + if (isObject(fill)) { + return isNaN(fill.value) ? false : fill; + } + let target = parseFloat(fill); + if (isNumberFinite(target) && Math.floor(target) === target) { + return decodeTargetIndex(fill[0], index, target, count); + } + return ['origin', 'start', 'end', 'stack', 'shape'].indexOf(fill) >= 0 && fill; +} +function decodeTargetIndex(firstCh, index, target, count) { + if (firstCh === '-' || firstCh === '+') { + target = index + target; + } + if (target === index || target < 0 || target >= count) { return false; } - function _clip(ctx, target, clipY) { - ctx.beginPath(); - target.path(ctx); - ctx.lineTo(target.last().x, clipY); - ctx.lineTo(target.first().x, clipY); - ctx.closePath(); - ctx.clip(); + return target; +} +function _getTargetPixel(fill, scale) { + let pixel = null; + if (fill === 'start') { + pixel = scale.bottom; + } else if (fill === 'end') { + pixel = scale.top; + } else if (isObject(fill)) { + pixel = scale.getPixelForValue(fill.value); + } else if (scale.getBasePixel) { + pixel = scale.getBasePixel(); + } + return pixel; +} +function _getTargetValue(fill, scale, startValue) { + let value; + if (fill === 'start') { + value = startValue; + } else if (fill === 'end') { + value = scale.options.reverse ? scale.min : scale.max; + } else if (isObject(fill)) { + value = fill.value; + } else { + value = scale.getBaseValue(); + } + return value; +} +function parseFillOption(line) { + const options = line.options; + const fillOption = options.fill; + let fill = valueOrDefault(fillOption && fillOption.target, fillOption); + if (fill === undefined) { + fill = !!options.backgroundColor; + } + if (fill === false || fill === null) { + return false; } - function getBounds(property, first, last, loop) { - if (loop) { - return; + if (fill === true) { + return 'origin'; + } + return fill; +} + +function _buildStackLine(source) { + const {scale, index, line} = source; + const points = []; + const segments = line.segments; + const sourcePoints = line.points; + const linesBelow = getLinesBelow(scale, index); + linesBelow.push(_createBoundaryLine({x: null, y: scale.bottom}, line)); + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + for (let j = segment.start; j <= segment.end; j++) { + addPointsBelow(points, sourcePoints[j], linesBelow); + } + } + return new LineElement({points, options: {}}); +} +function getLinesBelow(scale, index) { + const below = []; + const metas = scale.getMatchingVisibleMetas('line'); + for (let i = 0; i < metas.length; i++) { + const meta = metas[i]; + if (meta.index === index) { + break; + } + if (!meta.hidden) { + below.unshift(meta.dataset); + } + } + return below; +} +function addPointsBelow(points, sourcePoint, linesBelow) { + const postponed = []; + for (let j = 0; j < linesBelow.length; j++) { + const line = linesBelow[j]; + const {first, last, point} = findPoint(line, sourcePoint, 'x'); + if (!point || (first && last)) { + continue; + } + if (first) { + postponed.unshift(point); + } else { + points.push(point); + if (!last) { + break; + } } - let start = first[property]; - let end = last[property]; - if (property === 'angle') { - start = _normalizeAngle(start); - end = _normalizeAngle(end); + } + points.push(...postponed); +} +function findPoint(line, sourcePoint, property) { + const point = line.interpolate(sourcePoint, property); + if (!point) { + return {}; + } + const pointValue = point[property]; + const segments = line.segments; + const linePoints = line.points; + let first = false; + let last = false; + for (let i = 0; i < segments.length; i++) { + const segment = segments[i]; + const firstValue = linePoints[segment.start][property]; + const lastValue = linePoints[segment.end][property]; + if (_isBetween(pointValue, firstValue, lastValue)) { + first = pointValue === firstValue; + last = pointValue === lastValue; + break; } + } + return {first, last, point}; +} + +class simpleArc { + constructor(opts) { + this.x = opts.x; + this.y = opts.y; + this.radius = opts.radius; + } + pathSegment(ctx, bounds, opts) { + const {x, y, radius} = this; + bounds = bounds || {start: 0, end: TAU}; + ctx.arc(x, y, radius, bounds.end, bounds.start, true); + return !opts.bounds; + } + interpolate(point) { + const {x, y, radius} = this; + const angle = point.angle; return { - property: property, - start: start, - end: end + x: x + Math.cos(angle) * radius, + y: y + Math.sin(angle) * radius, + angle }; } - function _getEdge(a, b, prop, fn) { - if (a && b) { - return fn(a[prop], b[prop]); - } - return a ? a[prop] : b ? b[prop] : 0; - } - function _segments(line, target, property) { - const segments = line.segments; - const points = line.points; - const tpoints = target.points; - const parts = []; - for (let i = 0; i < segments.length; i++) { - const segment = segments[i]; - const bounds = getBounds(property, points[segment.start], points[segment.end], segment.loop); - if (!target.segments) { - parts.push({ - source: segment, - target: bounds, - start: points[segment.start], - end: points[segment.end] - }); - continue; - } - const subs = _boundSegments(target, bounds); - for (let j = 0; j < subs.length; ++j) { - const sub = subs[j]; - const subBounds = getBounds(property, tpoints[sub.start], tpoints[sub.end], sub.loop); - const fillSources = _boundSegment(segment, points, subBounds); - for (let k = 0; k < fillSources.length; k++) { - var _start, _end; - parts.push({ - source: fillSources[k], - target: sub, - start: (_start = {}, _start[property] = _getEdge(bounds, subBounds, 'start', Math.max), _start), - end: (_end = {}, _end[property] = _getEdge(bounds, subBounds, 'end', Math.min), _end) - }); - } - } - } - return parts; +} + +function _getTarget(source) { + const {chart, fill, line} = source; + if (isNumberFinite(fill)) { + return getLineByIndex(chart, fill); } - function clipBounds(ctx, scale, bounds) { - const _scale$chart$chartAre = scale.chart.chartArea, - top = _scale$chart$chartAre.top, - bottom = _scale$chart$chartAre.bottom; - const _ref2 = bounds || {}, - property = _ref2.property, - start = _ref2.start, - end = _ref2.end; - if (property === 'x') { - ctx.beginPath(); - ctx.rect(start, top, end - start, bottom - top); - ctx.clip(); - } + if (fill === 'stack') { + return _buildStackLine(source); } - function interpolatedLineTo(ctx, target, point, property) { - const interpolatedPoint = target.interpolate(point, property); - if (interpolatedPoint) { - ctx.lineTo(interpolatedPoint.x, interpolatedPoint.y); - } - } - function _fill(ctx, cfg) { - const line = cfg.line, - target = cfg.target, - property = cfg.property, - color = cfg.color, - scale = cfg.scale; - const segments = _segments(line, target, property); - ctx.fillStyle = color; - for (let i = 0, ilen = segments.length; i < ilen; ++i) { - const _segments$i = segments[i], - src = _segments$i.source, - tgt = _segments$i.target, - start = _segments$i.start, - end = _segments$i.end; - ctx.save(); - clipBounds(ctx, scale, getBounds(property, start, end)); - ctx.beginPath(); - const lineLoop = !!line.pathSegment(ctx, src); + if (fill === 'shape') { + return true; + } + const boundary = computeBoundary(source); + if (boundary instanceof simpleArc) { + return boundary; + } + return _createBoundaryLine(boundary, line); +} +function getLineByIndex(chart, index) { + const meta = chart.getDatasetMeta(index); + const visible = meta && chart.isDatasetVisible(index); + return visible ? meta.dataset : null; +} +function computeBoundary(source) { + const scale = source.scale || {}; + if (scale.getPointPositionForValue) { + return computeCircularBoundary(source); + } + return computeLinearBoundary(source); +} +function computeLinearBoundary(source) { + const {scale = {}, fill} = source; + const pixel = _getTargetPixel(fill, scale); + if (isNumberFinite(pixel)) { + const horizontal = scale.isHorizontal(); + return { + x: horizontal ? pixel : null, + y: horizontal ? null : pixel + }; + } + return null; +} +function computeCircularBoundary(source) { + const {scale, fill} = source; + const options = scale.options; + const length = scale.getLabels().length; + const start = options.reverse ? scale.max : scale.min; + const value = _getTargetValue(fill, scale, start); + const target = []; + if (options.grid.circular) { + const center = scale.getPointPositionForValue(0, start); + return new simpleArc({ + x: center.x, + y: center.y, + radius: scale.getDistanceFromCenterForValue(value) + }); + } + for (let i = 0; i < length; ++i) { + target.push(scale.getPointPositionForValue(i, value)); + } + return target; +} + +function _drawfill(ctx, source, area) { + const target = _getTarget(source); + const {line, scale, axis} = source; + const lineOpts = line.options; + const fillOption = lineOpts.fill; + const color = lineOpts.backgroundColor; + const {above = color, below = color} = fillOption || {}; + if (target && line.points.length) { + clipArea(ctx, area); + doFill(ctx, {line, target, above, below, area, scale, axis}); + unclipArea(ctx); + } +} +function doFill(ctx, cfg) { + const {line, target, above, below, area, scale} = cfg; + const property = line._loop ? 'angle' : cfg.axis; + ctx.save(); + if (property === 'x' && below !== above) { + clipVertical(ctx, target, area.top); + fill(ctx, {line, target, color: above, scale, property}); + ctx.restore(); + ctx.save(); + clipVertical(ctx, target, area.bottom); + } + fill(ctx, {line, target, color: below, scale, property}); + ctx.restore(); +} +function clipVertical(ctx, target, clipY) { + const {segments, points} = target; + let first = true; + let lineLoop = false; + ctx.beginPath(); + for (const segment of segments) { + const {start, end} = segment; + const firstPoint = points[start]; + const lastPoint = points[_findSegmentEnd(start, end, points)]; + if (first) { + ctx.moveTo(firstPoint.x, firstPoint.y); + first = false; + } else { + ctx.lineTo(firstPoint.x, clipY); + ctx.lineTo(firstPoint.x, firstPoint.y); + } + lineLoop = !!target.pathSegment(ctx, segment, {move: lineLoop}); + if (lineLoop) { + ctx.closePath(); + } else { + ctx.lineTo(lastPoint.x, clipY); + } + } + ctx.lineTo(target.first().x, clipY); + ctx.closePath(); + ctx.clip(); +} +function fill(ctx, cfg) { + const {line, target, property, color, scale} = cfg; + const segments = _segments(line, target, property); + for (const {source: src, target: tgt, start, end} of segments) { + const {style: {backgroundColor = color} = {}} = src; + const notShape = target !== true; + ctx.save(); + ctx.fillStyle = backgroundColor; + clipBounds(ctx, scale, notShape && _getBounds(property, start, end)); + ctx.beginPath(); + const lineLoop = !!line.pathSegment(ctx, src); + let loop; + if (notShape) { if (lineLoop) { ctx.closePath(); } else { interpolatedLineTo(ctx, target, end, property); } - const targetLoop = !!target.pathSegment(ctx, tgt, { - move: lineLoop, - reverse: true - }); - const loop = lineLoop && targetLoop; + const targetLoop = !!target.pathSegment(ctx, tgt, {move: lineLoop, reverse: true}); + loop = lineLoop && targetLoop; if (!loop) { interpolatedLineTo(ctx, target, start, property); } - ctx.closePath(); - ctx.fill(loop ? 'evenodd' : 'nonzero'); - ctx.restore(); } - } - function doFill(ctx, cfg) { - const line = cfg.line, - target = cfg.target, - above = cfg.above, - below = cfg.below, - area = cfg.area, - scale = cfg.scale; - const property = line._loop ? 'angle' : 'x'; - ctx.save(); - if (property === 'x' && below !== above) { - _clip(ctx, target, area.top); - _fill(ctx, { - line: line, - target: target, - color: above, - scale: scale, - property: property - }); - ctx.restore(); - ctx.save(); - _clip(ctx, target, area.bottom); - } - _fill(ctx, { - line: line, - target: target, - color: below, - scale: scale, - property: property - }); + ctx.closePath(); + ctx.fill(loop ? 'evenodd' : 'nonzero'); ctx.restore(); } - const plugin_filler = { - id: 'filler', - afterDatasetsUpdate: function afterDatasetsUpdate(chart, _args, options) { - const count = (chart.data.datasets || []).length; - const propagate = options.propagate; - const sources = []; - let meta, i, line, source; - for (i = 0; i < count; ++i) { - meta = chart.getDatasetMeta(i); - line = meta.dataset; - source = null; - if (line && line.options && line instanceof LineElement) { - source = { - visible: chart.isDatasetVisible(i), - index: i, - fill: decodeFill(line, i, count), - chart: chart, - scale: meta.vScale, - line: line - }; - } - meta.$filler = source; - sources.push(source); +} +function clipBounds(ctx, scale, bounds) { + const {top, bottom} = scale.chart.chartArea; + const {property, start, end} = bounds || {}; + if (property === 'x') { + ctx.beginPath(); + ctx.rect(start, top, end - start, bottom - top); + ctx.clip(); + } +} +function interpolatedLineTo(ctx, target, point, property) { + const interpolatedPoint = target.interpolate(point, property); + if (interpolatedPoint) { + ctx.lineTo(interpolatedPoint.x, interpolatedPoint.y); + } +} + +var index = { + id: 'filler', + afterDatasetsUpdate(chart, _args, options) { + const count = (chart.data.datasets || []).length; + const sources = []; + let meta, i, line, source; + for (i = 0; i < count; ++i) { + meta = chart.getDatasetMeta(i); + line = meta.dataset; + source = null; + if (line && line.options && line instanceof LineElement) { + source = { + visible: chart.isDatasetVisible(i), + index: i, + fill: _decodeFill(line, i, count), + chart, + axis: meta.controller.options.indexAxis, + scale: meta.vScale, + line, + }; } - for (i = 0; i < count; ++i) { - source = sources[i]; - if (!source || source.fill === false) { - continue; - } - source.fill = resolveTarget(sources, i, propagate); + meta.$filler = source; + sources.push(source); + } + for (i = 0; i < count; ++i) { + source = sources[i]; + if (!source || source.fill === false) { + continue; } - }, - beforeDatasetsDraw: function beforeDatasetsDraw(chart) { - const metasets = chart.getSortedVisibleDatasetMetas(); - const area = chart.chartArea; - let i, meta; - for (i = metasets.length - 1; i >= 0; --i) { - meta = metasets[i].$filler; - if (meta) { - meta.line.updateControlPoints(area); - } + source.fill = _resolveTarget(sources, i, options.propagate); + } + }, + beforeDraw(chart, _args, options) { + const draw = options.drawTime === 'beforeDraw'; + const metasets = chart.getSortedVisibleDatasetMetas(); + const area = chart.chartArea; + for (let i = metasets.length - 1; i >= 0; --i) { + const source = metasets[i].$filler; + if (!source) { + continue; } - }, - beforeDatasetDraw: function beforeDatasetDraw(chart, args) { - const area = chart.chartArea; - const ctx = chart.ctx; - const source = args.meta.$filler; - if (!source || source.fill === false) { - return; + source.line.updateControlPoints(area, source.axis); + if (draw && source.fill) { + _drawfill(chart.ctx, source, area); } - const target = getTarget(source); - const line = source.line, - scale = source.scale; - const lineOpts = line.options; - const fillOption = lineOpts.fill; - const color = lineOpts.backgroundColor; - const _ref3 = fillOption || {}, - _ref3$above = _ref3.above, - above = _ref3$above === void 0 ? color : _ref3$above, - _ref3$below = _ref3.below, - below = _ref3$below === void 0 ? color : _ref3$below; - if (target && line.points.length) { - clipArea(ctx, area); - doFill(ctx, { - line: line, - target: target, - above: above, - below: below, - area: area, - scale: scale - }); - unclipArea(ctx); + } + }, + beforeDatasetsDraw(chart, _args, options) { + if (options.drawTime !== 'beforeDatasetsDraw') { + return; + } + const metasets = chart.getSortedVisibleDatasetMetas(); + for (let i = metasets.length - 1; i >= 0; --i) { + const source = metasets[i].$filler; + if (_shouldApplyFill(source)) { + _drawfill(chart.ctx, source, chart.chartArea); } - }, - defaults: { - propagate: true } - }; - - function getBoxWidth(labelOpts, fontSize) { - const boxWidth = labelOpts.boxWidth; - return labelOpts.usePointStyle && boxWidth > fontSize || isNullOrUndef(boxWidth) ? fontSize : boxWidth; - } - function getBoxHeight(labelOpts, fontSize) { - const boxHeight = labelOpts.boxHeight; - return labelOpts.usePointStyle && boxHeight > fontSize || isNullOrUndef(boxHeight) ? fontSize : boxHeight; - } - const Legend = function (_Element) { - _inheritsLoose(Legend, _Element); - function Legend(config) { - let _this; - _this = _Element.call(this) || this; - _extends(_assertThisInitialized(_this), config); - _this.legendHitBoxes = []; - _this._hoveredItem = null; - _this.doughnutMode = false; - _this.chart = config.chart; - _this.options = config.options; - _this.ctx = config.ctx; - _this.legendItems = undefined; - _this.columnWidths = undefined; - _this.columnHeights = undefined; - _this.lineWidths = undefined; - _this._minSize = undefined; - _this.maxHeight = undefined; - _this.maxWidth = undefined; - _this.top = undefined; - _this.bottom = undefined; - _this.left = undefined; - _this.right = undefined; - _this.height = undefined; - _this.width = undefined; - _this._margins = undefined; - _this.paddingTop = undefined; - _this.paddingBottom = undefined; - _this.paddingLeft = undefined; - _this.paddingRight = undefined; - _this.position = undefined; - _this.weight = undefined; - _this.fullWidth = undefined; - return _this; - } - const _proto = Legend.prototype; - _proto.beforeUpdate = function beforeUpdate() {}; - _proto.update = function update(maxWidth, maxHeight, margins) { - const me = this; - me.beforeUpdate(); - me.maxWidth = maxWidth; - me.maxHeight = maxHeight; - me._margins = margins; - me.beforeSetDimensions(); - me.setDimensions(); - me.afterSetDimensions(); - me.beforeBuildLabels(); - me.buildLabels(); - me.afterBuildLabels(); - me.beforeFit(); - me.fit(); - me.afterFit(); - me.afterUpdate(); - }; - _proto.afterUpdate = function afterUpdate() {}; - _proto.beforeSetDimensions = function beforeSetDimensions() {}; - _proto.setDimensions = function setDimensions() { - const me = this; - if (me.isHorizontal()) { - me.width = me.maxWidth; - me.left = 0; - me.right = me.width; - } else { - me.height = me.maxHeight; - me.top = 0; - me.bottom = me.height; - } - me.paddingLeft = 0; - me.paddingTop = 0; - me.paddingRight = 0; - me.paddingBottom = 0; - me._minSize = { - width: 0, - height: 0 - }; - }; - _proto.afterSetDimensions = function afterSetDimensions() {}; - _proto.beforeBuildLabels = function beforeBuildLabels() {}; - _proto.buildLabels = function buildLabels() { - const me = this; - const labelOpts = me.options.labels || {}; - let legendItems = callback(labelOpts.generateLabels, [me.chart], me) || []; - if (labelOpts.filter) { - legendItems = legendItems.filter(function (item) { - return labelOpts.filter(item, me.chart.data); - }); + }, + beforeDatasetDraw(chart, args, options) { + const source = args.meta.$filler; + if (!_shouldApplyFill(source) || options.drawTime !== 'beforeDatasetDraw') { + return; + } + _drawfill(chart.ctx, source, chart.chartArea); + }, + defaults: { + propagate: true, + drawTime: 'beforeDatasetDraw' + } +}; + +const getBoxSize = (labelOpts, fontSize) => { + let {boxHeight = fontSize, boxWidth = fontSize} = labelOpts; + if (labelOpts.usePointStyle) { + boxHeight = Math.min(boxHeight, fontSize); + boxWidth = labelOpts.pointStyleWidth || Math.min(boxWidth, fontSize); + } + return { + boxWidth, + boxHeight, + itemHeight: Math.max(fontSize, boxHeight) + }; +}; +const itemsEqual = (a, b) => a !== null && b !== null && a.datasetIndex === b.datasetIndex && a.index === b.index; +class Legend extends Element { + constructor(config) { + super(); + this._added = false; + this.legendHitBoxes = []; + this._hoveredItem = null; + this.doughnutMode = false; + this.chart = config.chart; + this.options = config.options; + this.ctx = config.ctx; + this.legendItems = undefined; + this.columnSizes = undefined; + this.lineWidths = undefined; + this.maxHeight = undefined; + this.maxWidth = undefined; + this.top = undefined; + this.bottom = undefined; + this.left = undefined; + this.right = undefined; + this.height = undefined; + this.width = undefined; + this._margins = undefined; + this.position = undefined; + this.weight = undefined; + this.fullSize = undefined; + } + update(maxWidth, maxHeight, margins) { + this.maxWidth = maxWidth; + this.maxHeight = maxHeight; + this._margins = margins; + this.setDimensions(); + this.buildLabels(); + this.fit(); + } + setDimensions() { + if (this.isHorizontal()) { + this.width = this.maxWidth; + this.left = this._margins.left; + this.right = this.width; + } else { + this.height = this.maxHeight; + this.top = this._margins.top; + this.bottom = this.height; + } + } + buildLabels() { + const labelOpts = this.options.labels || {}; + let legendItems = callback(labelOpts.generateLabels, [this.chart], this) || []; + if (labelOpts.filter) { + legendItems = legendItems.filter((item) => labelOpts.filter(item, this.chart.data)); + } + if (labelOpts.sort) { + legendItems = legendItems.sort((a, b) => labelOpts.sort(a, b, this.chart.data)); + } + if (this.options.reverse) { + legendItems.reverse(); + } + this.legendItems = legendItems; + } + fit() { + const {options, ctx} = this; + if (!options.display) { + this.width = this.height = 0; + return; + } + const labelOpts = options.labels; + const labelFont = toFont(labelOpts.font); + const fontSize = labelFont.size; + const titleHeight = this._computeTitleHeight(); + const {boxWidth, itemHeight} = getBoxSize(labelOpts, fontSize); + let width, height; + ctx.font = labelFont.string; + if (this.isHorizontal()) { + width = this.maxWidth; + height = this._fitRows(titleHeight, fontSize, boxWidth, itemHeight) + 10; + } else { + height = this.maxHeight; + width = this._fitCols(titleHeight, fontSize, boxWidth, itemHeight) + 10; + } + this.width = Math.min(width, options.maxWidth || this.maxWidth); + this.height = Math.min(height, options.maxHeight || this.maxHeight); + } + _fitRows(titleHeight, fontSize, boxWidth, itemHeight) { + const {ctx, maxWidth, options: {labels: {padding}}} = this; + const hitboxes = this.legendHitBoxes = []; + const lineWidths = this.lineWidths = [0]; + const lineHeight = itemHeight + padding; + let totalHeight = titleHeight; + ctx.textAlign = 'left'; + ctx.textBaseline = 'middle'; + let row = -1; + let top = -lineHeight; + this.legendItems.forEach((legendItem, i) => { + const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width; + if (i === 0 || lineWidths[lineWidths.length - 1] + itemWidth + 2 * padding > maxWidth) { + totalHeight += lineHeight; + lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0; + top += lineHeight; + row++; + } + hitboxes[i] = {left: 0, top, row, width: itemWidth, height: itemHeight}; + lineWidths[lineWidths.length - 1] += itemWidth + padding; + }); + return totalHeight; + } + _fitCols(titleHeight, fontSize, boxWidth, itemHeight) { + const {ctx, maxHeight, options: {labels: {padding}}} = this; + const hitboxes = this.legendHitBoxes = []; + const columnSizes = this.columnSizes = []; + const heightLimit = maxHeight - titleHeight; + let totalWidth = padding; + let currentColWidth = 0; + let currentColHeight = 0; + let left = 0; + let col = 0; + this.legendItems.forEach((legendItem, i) => { + const itemWidth = boxWidth + (fontSize / 2) + ctx.measureText(legendItem.text).width; + if (i > 0 && currentColHeight + itemHeight + 2 * padding > heightLimit) { + totalWidth += currentColWidth + padding; + columnSizes.push({width: currentColWidth, height: currentColHeight}); + left += currentColWidth + padding; + col++; + currentColWidth = currentColHeight = 0; + } + hitboxes[i] = {left, top: currentColHeight, col, width: itemWidth, height: itemHeight}; + currentColWidth = Math.max(currentColWidth, itemWidth); + currentColHeight += itemHeight + padding; + }); + totalWidth += currentColWidth; + columnSizes.push({width: currentColWidth, height: currentColHeight}); + return totalWidth; + } + adjustHitBoxes() { + if (!this.options.display) { + return; + } + const titleHeight = this._computeTitleHeight(); + const {legendHitBoxes: hitboxes, options: {align, labels: {padding}, rtl}} = this; + const rtlHelper = getRtlAdapter(rtl, this.left, this.width); + if (this.isHorizontal()) { + let row = 0; + let left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]); + for (const hitbox of hitboxes) { + if (row !== hitbox.row) { + row = hitbox.row; + left = _alignStartEnd(align, this.left + padding, this.right - this.lineWidths[row]); + } + hitbox.top += this.top + titleHeight + padding; + hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(left), hitbox.width); + left += hitbox.width + padding; } - if (labelOpts.sort) { - legendItems = legendItems.sort(function (a, b) { - return labelOpts.sort(a, b, me.chart.data); - }); - } - if (me.options.reverse) { - legendItems.reverse(); - } - me.legendItems = legendItems; - }; - _proto.afterBuildLabels = function afterBuildLabels() {}; - _proto.beforeFit = function beforeFit() {}; - _proto.fit = function fit() { - const me = this; - const opts = me.options; - const labelOpts = opts.labels; - const display = opts.display; - const ctx = me.ctx; - const labelFont = toFont(labelOpts.font, me.chart.options.font); - const fontSize = labelFont.size; - const boxWidth = getBoxWidth(labelOpts, fontSize); - const boxHeight = getBoxHeight(labelOpts, fontSize); - const itemHeight = Math.max(boxHeight, fontSize); - const hitboxes = me.legendHitBoxes = []; - const minSize = me._minSize; - const isHorizontal = me.isHorizontal(); - const titleHeight = me._computeTitleHeight(); - if (isHorizontal) { - minSize.width = me.maxWidth; - minSize.height = display ? 10 : 0; - } else { - minSize.width = display ? 10 : 0; - minSize.height = me.maxHeight; + } else { + let col = 0; + let top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height); + for (const hitbox of hitboxes) { + if (hitbox.col !== col) { + col = hitbox.col; + top = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - this.columnSizes[col].height); + } + hitbox.top = top; + hitbox.left += this.left + padding; + hitbox.left = rtlHelper.leftForLtr(rtlHelper.x(hitbox.left), hitbox.width); + top += hitbox.height + padding; } - if (!display) { - me.width = minSize.width = me.height = minSize.height = 0; + } + } + isHorizontal() { + return this.options.position === 'top' || this.options.position === 'bottom'; + } + draw() { + if (this.options.display) { + const ctx = this.ctx; + clipArea(ctx, this); + this._draw(); + unclipArea(ctx); + } + } + _draw() { + const {options: opts, columnSizes, lineWidths, ctx} = this; + const {align, labels: labelOpts} = opts; + const defaultColor = defaults.color; + const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width); + const labelFont = toFont(labelOpts.font); + const {color: fontColor, padding} = labelOpts; + const fontSize = labelFont.size; + const halfFontSize = fontSize / 2; + let cursor; + this.drawTitle(); + ctx.textAlign = rtlHelper.textAlign('left'); + ctx.textBaseline = 'middle'; + ctx.lineWidth = 0.5; + ctx.font = labelFont.string; + const {boxWidth, boxHeight, itemHeight} = getBoxSize(labelOpts, fontSize); + const drawLegendBox = function(x, y, legendItem) { + if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) { return; } - ctx.font = labelFont.string; - if (isHorizontal) { - const lineWidths = me.lineWidths = [0]; - let totalHeight = titleHeight; - ctx.textAlign = 'left'; - ctx.textBaseline = 'middle'; - me.legendItems.forEach(function (legendItem, i) { - const width = boxWidth + fontSize / 2 + ctx.measureText(legendItem.text).width; - if (i === 0 || lineWidths[lineWidths.length - 1] + width + 2 * labelOpts.padding > minSize.width) { - totalHeight += itemHeight + labelOpts.padding; - lineWidths[lineWidths.length - (i > 0 ? 0 : 1)] = 0; - } - hitboxes[i] = { - left: 0, - top: 0, - width: width, - height: itemHeight - }; - lineWidths[lineWidths.length - 1] += width + labelOpts.padding; - }); - minSize.height += totalHeight; + ctx.save(); + const lineWidth = valueOrDefault(legendItem.lineWidth, 1); + ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor); + ctx.lineCap = valueOrDefault(legendItem.lineCap, 'butt'); + ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0); + ctx.lineJoin = valueOrDefault(legendItem.lineJoin, 'miter'); + ctx.lineWidth = lineWidth; + ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor); + ctx.setLineDash(valueOrDefault(legendItem.lineDash, [])); + if (labelOpts.usePointStyle) { + const drawOptions = { + radius: boxHeight * Math.SQRT2 / 2, + pointStyle: legendItem.pointStyle, + rotation: legendItem.rotation, + borderWidth: lineWidth + }; + const centerX = rtlHelper.xPlus(x, boxWidth / 2); + const centerY = y + halfFontSize; + drawPointLegend(ctx, drawOptions, centerX, centerY, labelOpts.pointStyleWidth && boxWidth); } else { - const vPadding = labelOpts.padding; - const columnWidths = me.columnWidths = []; - const columnHeights = me.columnHeights = []; - let totalWidth = labelOpts.padding; - let currentColWidth = 0; - let currentColHeight = 0; - const heightLimit = minSize.height - titleHeight; - me.legendItems.forEach(function (legendItem, i) { - const itemWidth = boxWidth + fontSize / 2 + ctx.measureText(legendItem.text).width; - if (i > 0 && currentColHeight + fontSize + 2 * vPadding > heightLimit) { - totalWidth += currentColWidth + labelOpts.padding; - columnWidths.push(currentColWidth); - columnHeights.push(currentColHeight); - currentColWidth = 0; - currentColHeight = 0; - } - currentColWidth = Math.max(currentColWidth, itemWidth); - currentColHeight += fontSize + vPadding; - hitboxes[i] = { - left: 0, - top: 0, - width: itemWidth, - height: itemHeight - }; - }); - totalWidth += currentColWidth; - columnWidths.push(currentColWidth); - columnHeights.push(currentColHeight); - minSize.width += totalWidth; - } - me.width = Math.min(minSize.width, opts.maxWidth || INFINITY); - me.height = Math.min(minSize.height, opts.maxHeight || INFINITY); - }; - _proto.afterFit = function afterFit() {} - ; - _proto.isHorizontal = function isHorizontal() { - return this.options.position === 'top' || this.options.position === 'bottom'; - } - ; - _proto.draw = function draw() { - const me = this; - const opts = me.options; - const labelOpts = opts.labels; - const defaultColor = defaults.color; - const legendHeight = me.height; - const columnHeights = me.columnHeights; - const legendWidth = me.width; - const lineWidths = me.lineWidths; - if (!opts.display) { - return; - } - me.drawTitle(); - const rtlHelper = getRtlAdapter(opts.rtl, me.left, me._minSize.width); - const ctx = me.ctx; - const labelFont = toFont(labelOpts.font, me.chart.options.font); - const fontColor = labelFont.color; - const fontSize = labelFont.size; - let cursor; - ctx.textAlign = rtlHelper.textAlign('left'); - ctx.textBaseline = 'middle'; - ctx.lineWidth = 0.5; - ctx.strokeStyle = fontColor; - ctx.fillStyle = fontColor; - ctx.font = labelFont.string; - const boxWidth = getBoxWidth(labelOpts, fontSize); - const boxHeight = getBoxHeight(labelOpts, fontSize); - const height = Math.max(fontSize, boxHeight); - const hitboxes = me.legendHitBoxes; - const drawLegendBox = function drawLegendBox(x, y, legendItem) { - if (isNaN(boxWidth) || boxWidth <= 0 || isNaN(boxHeight) || boxHeight < 0) { - return; - } - ctx.save(); - const lineWidth = valueOrDefault(legendItem.lineWidth, 1); - ctx.fillStyle = valueOrDefault(legendItem.fillStyle, defaultColor); - ctx.lineCap = valueOrDefault(legendItem.lineCap, 'butt'); - ctx.lineDashOffset = valueOrDefault(legendItem.lineDashOffset, 0); - ctx.lineJoin = valueOrDefault(legendItem.lineJoin, 'miter'); - ctx.lineWidth = lineWidth; - ctx.strokeStyle = valueOrDefault(legendItem.strokeStyle, defaultColor); - if (ctx.setLineDash) { - ctx.setLineDash(valueOrDefault(legendItem.lineDash, [])); - } - if (labelOpts && labelOpts.usePointStyle) { - const drawOptions = { - radius: boxWidth * Math.SQRT2 / 2, - pointStyle: legendItem.pointStyle, - rotation: legendItem.rotation, - borderWidth: lineWidth - }; - const centerX = rtlHelper.xPlus(x, boxWidth / 2); - const centerY = y + fontSize / 2; - drawPoint(ctx, drawOptions, centerX, centerY); + const yBoxTop = y + Math.max((fontSize - boxHeight) / 2, 0); + const xBoxLeft = rtlHelper.leftForLtr(x, boxWidth); + const borderRadius = toTRBLCorners(legendItem.borderRadius); + ctx.beginPath(); + if (Object.values(borderRadius).some(v => v !== 0)) { + addRoundedRectPath(ctx, { + x: xBoxLeft, + y: yBoxTop, + w: boxWidth, + h: boxHeight, + radius: borderRadius, + }); } else { - const yBoxTop = y + Math.max((fontSize - boxHeight) / 2, 0); - ctx.fillRect(rtlHelper.leftForLtr(x, boxWidth), yBoxTop, boxWidth, boxHeight); - if (lineWidth !== 0) { - ctx.strokeRect(rtlHelper.leftForLtr(x, boxWidth), yBoxTop, boxWidth, boxHeight); - } + ctx.rect(xBoxLeft, yBoxTop, boxWidth, boxHeight); } - ctx.restore(); - }; - const fillText = function fillText(x, y, legendItem, textWidth) { - const halfFontSize = fontSize / 2; - const xLeft = rtlHelper.xPlus(x, boxWidth + halfFontSize); - const yMiddle = y + height / 2; - ctx.fillText(legendItem.text, xLeft, yMiddle); - if (legendItem.hidden) { - ctx.beginPath(); - ctx.lineWidth = 2; - ctx.moveTo(xLeft, yMiddle); - ctx.lineTo(rtlHelper.xPlus(xLeft, textWidth), yMiddle); + ctx.fill(); + if (lineWidth !== 0) { ctx.stroke(); } + } + ctx.restore(); + }; + const fillText = function(x, y, legendItem) { + renderText(ctx, legendItem.text, x, y + (itemHeight / 2), labelFont, { + strikethrough: legendItem.hidden, + textAlign: rtlHelper.textAlign(legendItem.textAlign) + }); + }; + const isHorizontal = this.isHorizontal(); + const titleHeight = this._computeTitleHeight(); + if (isHorizontal) { + cursor = { + x: _alignStartEnd(align, this.left + padding, this.right - lineWidths[0]), + y: this.top + padding + titleHeight, + line: 0 }; - const alignmentOffset = function alignmentOffset(dimension, blockSize) { - switch (opts.align) { - case 'start': - return labelOpts.padding; - case 'end': - return dimension - blockSize; - default: - return (dimension - blockSize + labelOpts.padding) / 2; - } + } else { + cursor = { + x: this.left + padding, + y: _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[0].height), + line: 0 }; - const isHorizontal = me.isHorizontal(); - const titleHeight = this._computeTitleHeight(); + } + overrideTextDirection(this.ctx, opts.textDirection); + const lineHeight = itemHeight + padding; + this.legendItems.forEach((legendItem, i) => { + ctx.strokeStyle = legendItem.fontColor || fontColor; + ctx.fillStyle = legendItem.fontColor || fontColor; + const textWidth = ctx.measureText(legendItem.text).width; + const textAlign = rtlHelper.textAlign(legendItem.textAlign || (legendItem.textAlign = labelOpts.textAlign)); + const width = boxWidth + halfFontSize + textWidth; + let x = cursor.x; + let y = cursor.y; + rtlHelper.setWidth(this.width); if (isHorizontal) { - cursor = { - x: me.left + alignmentOffset(legendWidth, lineWidths[0]), - y: me.top + labelOpts.padding + titleHeight, - line: 0 - }; - } else { - cursor = { - x: me.left + labelOpts.padding, - y: me.top + alignmentOffset(legendHeight, columnHeights[0]) + titleHeight, - line: 0 - }; - } - overrideTextDirection(me.ctx, opts.textDirection); - const itemHeight = height + labelOpts.padding; - me.legendItems.forEach(function (legendItem, i) { - const textWidth = ctx.measureText(legendItem.text).width; - const width = boxWidth + fontSize / 2 + textWidth; - let x = cursor.x; - let y = cursor.y; - rtlHelper.setWidth(me._minSize.width); - if (isHorizontal) { - if (i > 0 && x + width + labelOpts.padding > me.left + me._minSize.width) { - y = cursor.y += itemHeight; - cursor.line++; - x = cursor.x = me.left + alignmentOffset(legendWidth, lineWidths[cursor.line]); - } - } else if (i > 0 && y + itemHeight > me.top + me._minSize.height) { - x = cursor.x = x + me.columnWidths[cursor.line] + labelOpts.padding; + if (i > 0 && x + width + padding > this.right) { + y = cursor.y += lineHeight; cursor.line++; - y = cursor.y = me.top + alignmentOffset(legendHeight, columnHeights[cursor.line]); - } - const realX = rtlHelper.x(x); - drawLegendBox(realX, y, legendItem); - hitboxes[i].left = rtlHelper.leftForLtr(realX, hitboxes[i].width); - hitboxes[i].top = y; - fillText(realX, y, legendItem, textWidth); - if (isHorizontal) { - cursor.x += width + labelOpts.padding; - } else { - cursor.y += itemHeight; + x = cursor.x = _alignStartEnd(align, this.left + padding, this.right - lineWidths[cursor.line]); } - }); - restoreTextDirection(me.ctx, opts.textDirection); - } - ; - _proto.drawTitle = function drawTitle() { - const me = this; - const opts = me.options; - const titleOpts = opts.title; - const titleFont = toFont(titleOpts.font, me.chart.options.font); - const titlePadding = toPadding(titleOpts.padding); - if (!titleOpts.display) { - return; + } else if (i > 0 && y + lineHeight > this.bottom) { + x = cursor.x = x + columnSizes[cursor.line].width + padding; + cursor.line++; + y = cursor.y = _alignStartEnd(align, this.top + titleHeight + padding, this.bottom - columnSizes[cursor.line].height); } - const rtlHelper = getRtlAdapter(opts.rtl, me.left, me._minSize.width); - const ctx = me.ctx; - const position = titleOpts.position; - let x, textAlign; - const halfFontSize = titleFont.size / 2; - let y = me.top + titlePadding.top + halfFontSize; - let left = me.left; - let maxWidth = me.width; - if (this.isHorizontal()) { - maxWidth = Math.max.apply(Math, me.lineWidths); - switch (opts.align) { - case 'start': - break; - case 'end': - left = me.right - maxWidth; - break; - default: - left = (me.left + me.right) / 2 - maxWidth / 2; - break; - } + const realX = rtlHelper.x(x); + drawLegendBox(realX, y, legendItem); + x = _textX(textAlign, x + boxWidth + halfFontSize, isHorizontal ? x + width : this.right, opts.rtl); + fillText(rtlHelper.x(x), y, legendItem); + if (isHorizontal) { + cursor.x += width + padding; } else { - const maxHeight = Math.max.apply(Math, me.columnHeights); - switch (opts.align) { - case 'start': - break; - case 'end': - y += me.height - maxHeight; - break; - default: - y += (me.height - maxHeight) / 2; - break; - } - } - switch (position) { - case 'start': - x = left; - textAlign = 'left'; - break; - case 'end': - x = left + maxWidth; - textAlign = 'right'; - break; - default: - x = left + maxWidth / 2; - textAlign = 'center'; - break; - } - ctx.textAlign = rtlHelper.textAlign(textAlign); - ctx.textBaseline = 'middle'; - ctx.strokeStyle = titleFont.color; - ctx.fillStyle = titleFont.color; - ctx.font = titleFont.string; - ctx.fillText(titleOpts.text, x, y); - } - ; - _proto._computeTitleHeight = function _computeTitleHeight() { - const titleOpts = this.options.title; - const titleFont = toFont(titleOpts.font, this.chart.options.font); - const titlePadding = toPadding(titleOpts.padding); - return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0; - } - ; - _proto._getLegendItemAt = function _getLegendItemAt(x, y) { - const me = this; - let i, hitBox, lh; - if (x >= me.left && x <= me.right && y >= me.top && y <= me.bottom) { - lh = me.legendHitBoxes; - for (i = 0; i < lh.length; ++i) { - hitBox = lh[i]; - if (x >= hitBox.left && x <= hitBox.left + hitBox.width && y >= hitBox.top && y <= hitBox.top + hitBox.height) { - return me.legendItems[i]; - } - } + cursor.y += lineHeight; } - return null; + }); + restoreTextDirection(this.ctx, opts.textDirection); + } + drawTitle() { + const opts = this.options; + const titleOpts = opts.title; + const titleFont = toFont(titleOpts.font); + const titlePadding = toPadding(titleOpts.padding); + if (!titleOpts.display) { + return; } - ; - _proto.handleEvent = function handleEvent(e) { - const me = this; - const opts = me.options; - const type = e.type === 'mouseup' ? 'click' : e.type; - if (type === 'mousemove') { - if (!opts.onHover && !opts.onLeave) { - return; - } - } else if (type === 'click') { - if (!opts.onClick) { - return; - } - } else { - return; - } - const hoveredItem = me._getLegendItemAt(e.x, e.y); - if (type === 'click') { - if (hoveredItem) { - callback(opts.onClick, [e, hoveredItem, me], me); - } - } else { - if (opts.onLeave && hoveredItem !== me._hoveredItem) { - if (me._hoveredItem) { - callback(opts.onLeave, [e, me._hoveredItem, me], me); - } - me._hoveredItem = hoveredItem; - } - if (hoveredItem) { - callback(opts.onHover, [e, hoveredItem, me], me); - } - } - }; - return Legend; - }(Element$1); - function resolveOptions(options) { - return options !== false && merge(Object.create(null), [defaults.plugins.legend, options]); + const rtlHelper = getRtlAdapter(opts.rtl, this.left, this.width); + const ctx = this.ctx; + const position = titleOpts.position; + const halfFontSize = titleFont.size / 2; + const topPaddingPlusHalfFontSize = titlePadding.top + halfFontSize; + let y; + let left = this.left; + let maxWidth = this.width; + if (this.isHorizontal()) { + maxWidth = Math.max(...this.lineWidths); + y = this.top + topPaddingPlusHalfFontSize; + left = _alignStartEnd(opts.align, left, this.right - maxWidth); + } else { + const maxHeight = this.columnSizes.reduce((acc, size) => Math.max(acc, size.height), 0); + y = topPaddingPlusHalfFontSize + _alignStartEnd(opts.align, this.top, this.bottom - maxHeight - opts.labels.padding - this._computeTitleHeight()); + } + const x = _alignStartEnd(position, left, left + maxWidth); + ctx.textAlign = rtlHelper.textAlign(_toLeftRightCenter(position)); + ctx.textBaseline = 'middle'; + ctx.strokeStyle = titleOpts.color; + ctx.fillStyle = titleOpts.color; + ctx.font = titleFont.string; + renderText(ctx, titleOpts.text, x, y, titleFont); } - function createNewLegendAndAttach(chart, legendOpts) { - const legend = new Legend({ - ctx: chart.ctx, - options: legendOpts, - chart: chart - }); - layouts.configure(chart, legend, legendOpts); - layouts.addBox(chart, legend); - chart.legend = legend; + _computeTitleHeight() { + const titleOpts = this.options.title; + const titleFont = toFont(titleOpts.font); + const titlePadding = toPadding(titleOpts.padding); + return titleOpts.display ? titleFont.lineHeight + titlePadding.height : 0; } - const plugin_legend = { - id: 'legend', - _element: Legend, - beforeInit: function beforeInit(chart) { - const legendOpts = resolveOptions(chart.options.legend); - if (legendOpts) { - createNewLegendAndAttach(chart, legendOpts); - } - }, - beforeUpdate: function beforeUpdate(chart) { - const legendOpts = resolveOptions(chart.options.legend); - const legend = chart.legend; - if (legendOpts) { - if (legend) { - layouts.configure(chart, legend, legendOpts); - legend.options = legendOpts; - } else { - createNewLegendAndAttach(chart, legendOpts); - } - } else if (legend) { - layouts.removeBox(chart, legend); - delete chart.legend; - } - }, - afterUpdate: function afterUpdate(chart) { - if (chart.legend) { - chart.legend.buildLabels(); - } - }, - afterEvent: function afterEvent(chart, e) { - const legend = chart.legend; - if (legend) { - legend.handleEvent(e); - } - }, - defaults: { - display: true, - position: 'top', - align: 'center', - fullWidth: true, - reverse: false, - weight: 1000, - onClick: function onClick(e, legendItem, legend) { - const index = legendItem.datasetIndex; - const ci = legend.chart; - if (ci.isDatasetVisible(index)) { - ci.hide(index); - legendItem.hidden = true; - } else { - ci.show(index); - legendItem.hidden = false; - } - }, - onHover: null, - onLeave: null, - labels: { - boxWidth: 40, - padding: 10, - generateLabels: function generateLabels(chart) { - const datasets = chart.data.datasets; - const labels = chart.legend.options.labels; - const usePointStyle = labels.usePointStyle; - const overrideStyle = labels.pointStyle; - return chart._getSortedDatasetMetas().map(function (meta) { - const style = meta.controller.getStyle(usePointStyle ? 0 : undefined); - const borderWidth = isObject(style.borderWidth) ? (valueOrDefault(style.borderWidth.top, 0) + valueOrDefault(style.borderWidth.left, 0) + valueOrDefault(style.borderWidth.bottom, 0) + valueOrDefault(style.borderWidth.right, 0)) / 4 : style.borderWidth; - return { - text: datasets[meta.index].label, - fillStyle: style.backgroundColor, - hidden: !meta.visible, - lineCap: style.borderCapStyle, - lineDash: style.borderDash, - lineDashOffset: style.borderDashOffset, - lineJoin: style.borderJoinStyle, - lineWidth: borderWidth, - strokeStyle: style.borderColor, - pointStyle: overrideStyle || style.pointStyle, - rotation: style.rotation, - datasetIndex: meta.index - }; - }, this); + _getLegendItemAt(x, y) { + let i, hitBox, lh; + if (_isBetween(x, this.left, this.right) + && _isBetween(y, this.top, this.bottom)) { + lh = this.legendHitBoxes; + for (i = 0; i < lh.length; ++i) { + hitBox = lh[i]; + if (_isBetween(x, hitBox.left, hitBox.left + hitBox.width) + && _isBetween(y, hitBox.top, hitBox.top + hitBox.height)) { + return this.legendItems[i]; } - }, - title: { - display: false, - position: 'center', - text: '' } } - }; - - const Title = function (_Element) { - _inheritsLoose(Title, _Element); - function Title(config) { - let _this; - _this = _Element.call(this) || this; - _extends(_assertThisInitialized(_this), config); - _this.chart = config.chart; - _this.options = config.options; - _this.ctx = config.ctx; - _this._margins = undefined; - _this._padding = undefined; - _this.top = undefined; - _this.bottom = undefined; - _this.left = undefined; - _this.right = undefined; - _this.width = undefined; - _this.height = undefined; - _this.maxWidth = undefined; - _this.maxHeight = undefined; - _this.position = undefined; - _this.weight = undefined; - _this.fullWidth = undefined; - return _this; - } - const _proto = Title.prototype; - _proto.beforeUpdate = function beforeUpdate() {}; - _proto.update = function update(maxWidth, maxHeight, margins) { - const me = this; - me.beforeUpdate(); - me.maxWidth = maxWidth; - me.maxHeight = maxHeight; - me._margins = margins; - me.beforeSetDimensions(); - me.setDimensions(); - me.afterSetDimensions(); - me.beforeBuildLabels(); - me.buildLabels(); - me.afterBuildLabels(); - me.beforeFit(); - me.fit(); - me.afterFit(); - me.afterUpdate(); - }; - _proto.afterUpdate = function afterUpdate() {}; - _proto.beforeSetDimensions = function beforeSetDimensions() {}; - _proto.setDimensions = function setDimensions() { - const me = this; - if (me.isHorizontal()) { - me.width = me.maxWidth; - me.left = 0; - me.right = me.width; - } else { - me.height = me.maxHeight; - me.top = 0; - me.bottom = me.height; - } - }; - _proto.afterSetDimensions = function afterSetDimensions() {}; - _proto.beforeBuildLabels = function beforeBuildLabels() {}; - _proto.buildLabels = function buildLabels() {}; - _proto.afterBuildLabels = function afterBuildLabels() {}; - _proto.beforeFit = function beforeFit() {}; - _proto.fit = function fit() { - const me = this; - const opts = me.options; - const minSize = {}; - const isHorizontal = me.isHorizontal(); - if (!opts.display) { - me.width = minSize.width = me.height = minSize.height = 0; - return; - } - const lineCount = isArray(opts.text) ? opts.text.length : 1; - me._padding = toPadding(opts.padding); - const textSize = lineCount * toFont(opts.font, me.chart.options.font).lineHeight + me._padding.height; - me.width = minSize.width = isHorizontal ? me.maxWidth : textSize; - me.height = minSize.height = isHorizontal ? textSize : me.maxHeight; - }; - _proto.afterFit = function afterFit() {} - ; - _proto.isHorizontal = function isHorizontal() { - const pos = this.options.position; - return pos === 'top' || pos === 'bottom'; - } - ; - _proto.draw = function draw() { - const me = this; - const ctx = me.ctx; - const opts = me.options; - if (!opts.display) { - return; - } - const fontOpts = toFont(opts.font, me.chart.options.font); - const lineHeight = fontOpts.lineHeight; - const offset = lineHeight / 2 + me._padding.top; - let rotation = 0; - const top = me.top; - const left = me.left; - const bottom = me.bottom; - const right = me.right; - let maxWidth, titleX, titleY; - let align; - if (me.isHorizontal()) { - switch (opts.align) { - case 'start': - titleX = left; - align = 'left'; - break; - case 'end': - titleX = right; - align = 'right'; - break; - default: - titleX = left + (right - left) / 2; - align = 'center'; - break; - } - titleY = top + offset; - maxWidth = right - left; - } else { - titleX = opts.position === 'left' ? left + offset : right - offset; - switch (opts.align) { - case 'start': - titleY = opts.position === 'left' ? bottom : top; - align = 'left'; - break; - case 'end': - titleY = opts.position === 'left' ? top : bottom; - align = 'right'; - break; - default: - titleY = top + (bottom - top) / 2; - align = 'center'; - break; - } - maxWidth = bottom - top; - rotation = PI * (opts.position === 'left' ? -0.5 : 0.5); + return null; + } + handleEvent(e) { + const opts = this.options; + if (!isListened(e.type, opts)) { + return; + } + const hoveredItem = this._getLegendItemAt(e.x, e.y); + if (e.type === 'mousemove' || e.type === 'mouseout') { + const previous = this._hoveredItem; + const sameItem = itemsEqual(previous, hoveredItem); + if (previous && !sameItem) { + callback(opts.onLeave, [e, previous, this], this); } - ctx.save(); - ctx.fillStyle = fontOpts.color; - ctx.font = fontOpts.string; - ctx.translate(titleX, titleY); - ctx.rotate(rotation); - ctx.textAlign = align; - ctx.textBaseline = 'middle'; - const text = opts.text; - if (isArray(text)) { - let y = 0; - for (let i = 0; i < text.length; ++i) { - ctx.fillText(text[i], 0, y, maxWidth); - y += lineHeight; - } - } else { - ctx.fillText(text, 0, 0, maxWidth); + this._hoveredItem = hoveredItem; + if (hoveredItem && !sameItem) { + callback(opts.onHover, [e, hoveredItem, this], this); } - ctx.restore(); - }; - return Title; - }(Element$1); - function createNewTitleBlockAndAttach(chart, titleOpts) { - const title = new Title({ - ctx: chart.ctx, - options: titleOpts, - chart: chart - }); - layouts.configure(chart, title, titleOpts); - layouts.addBox(chart, title); - chart.titleBlock = title; + } else if (hoveredItem) { + callback(opts.onClick, [e, hoveredItem, this], this); + } + } +} +function isListened(type, opts) { + if ((type === 'mousemove' || type === 'mouseout') && (opts.onHover || opts.onLeave)) { + return true; + } + if (opts.onClick && (type === 'click' || type === 'mouseup')) { + return true; } - const plugin_title = { - id: 'title', - _element: Title, - beforeInit: function beforeInit(chart) { - const titleOpts = chart.options.title; - if (titleOpts) { - createNewTitleBlockAndAttach(chart, titleOpts); + return false; +} +var plugin_legend = { + id: 'legend', + _element: Legend, + start(chart, _args, options) { + const legend = chart.legend = new Legend({ctx: chart.ctx, options, chart}); + layouts.configure(chart, legend, options); + layouts.addBox(chart, legend); + }, + stop(chart) { + layouts.removeBox(chart, chart.legend); + delete chart.legend; + }, + beforeUpdate(chart, _args, options) { + const legend = chart.legend; + layouts.configure(chart, legend, options); + legend.options = options; + }, + afterUpdate(chart) { + const legend = chart.legend; + legend.buildLabels(); + legend.adjustHitBoxes(); + }, + afterEvent(chart, args) { + if (!args.replay) { + chart.legend.handleEvent(args.event); + } + }, + defaults: { + display: true, + position: 'top', + align: 'center', + fullSize: true, + reverse: false, + weight: 1000, + onClick(e, legendItem, legend) { + const index = legendItem.datasetIndex; + const ci = legend.chart; + if (ci.isDatasetVisible(index)) { + ci.hide(index); + legendItem.hidden = true; + } else { + ci.show(index); + legendItem.hidden = false; } }, - beforeUpdate: function beforeUpdate(chart) { - const titleOpts = chart.options.title; - const titleBlock = chart.titleBlock; - if (titleOpts) { - mergeIf(titleOpts, defaults.plugins.title); - if (titleBlock) { - layouts.configure(chart, titleBlock, titleOpts); - titleBlock.options = titleOpts; - } else { - createNewTitleBlockAndAttach(chart, titleOpts); - } - } else if (titleBlock) { - layouts.removeBox(chart, titleBlock); - delete chart.titleBlock; + onHover: null, + onLeave: null, + labels: { + color: (ctx) => ctx.chart.options.color, + boxWidth: 40, + padding: 10, + generateLabels(chart) { + const datasets = chart.data.datasets; + const {labels: {usePointStyle, pointStyle, textAlign, color}} = chart.legend.options; + return chart._getSortedDatasetMetas().map((meta) => { + const style = meta.controller.getStyle(usePointStyle ? 0 : undefined); + const borderWidth = toPadding(style.borderWidth); + return { + text: datasets[meta.index].label, + fillStyle: style.backgroundColor, + fontColor: color, + hidden: !meta.visible, + lineCap: style.borderCapStyle, + lineDash: style.borderDash, + lineDashOffset: style.borderDashOffset, + lineJoin: style.borderJoinStyle, + lineWidth: (borderWidth.width + borderWidth.height) / 4, + strokeStyle: style.borderColor, + pointStyle: pointStyle || style.pointStyle, + rotation: style.rotation, + textAlign: textAlign || style.textAlign, + borderRadius: 0, + datasetIndex: meta.index + }; + }, this); } }, - defaults: { - align: 'center', + title: { + color: (ctx) => ctx.chart.options.color, display: false, - font: { - style: 'bold' - }, - fullWidth: true, - padding: 10, - position: 'top', + position: 'center', text: '', - weight: 2000 } - }; + }, + descriptors: { + _scriptable: (name) => !name.startsWith('on'), + labels: { + _scriptable: (name) => !['generateLabels', 'filter', 'sort'].includes(name), + } + }, +}; - const positioners = { - average: function average(items) { - if (!items.length) { - return false; - } - let i, len; - let x = 0; - let y = 0; - let count = 0; - for (i = 0, len = items.length; i < len; ++i) { - const el = items[i].element; - if (el && el.hasValue()) { - const pos = el.tooltipPosition(); - x += pos.x; - y += pos.y; - ++count; - } - } - return { - x: x / count, - y: y / count - }; - }, - nearest: function nearest(items, eventPosition) { - let x = eventPosition.x; - let y = eventPosition.y; - let minDistance = Number.POSITIVE_INFINITY; - let i, len, nearestElement; - for (i = 0, len = items.length; i < len; ++i) { - const el = items[i].element; - if (el && el.hasValue()) { - const center = el.getCenterPoint(); - const d = distanceBetweenPoints(eventPosition, center); - if (d < minDistance) { - minDistance = d; - nearestElement = el; - } - } - } - if (nearestElement) { - const tp = nearestElement.tooltipPosition(); - x = tp.x; - y = tp.y; - } - return { - x: x, - y: y - }; +class Title extends Element { + constructor(config) { + super(); + this.chart = config.chart; + this.options = config.options; + this.ctx = config.ctx; + this._padding = undefined; + this.top = undefined; + this.bottom = undefined; + this.left = undefined; + this.right = undefined; + this.width = undefined; + this.height = undefined; + this.position = undefined; + this.weight = undefined; + this.fullSize = undefined; + } + update(maxWidth, maxHeight) { + const opts = this.options; + this.left = 0; + this.top = 0; + if (!opts.display) { + this.width = this.height = this.right = this.bottom = 0; + return; } - }; - function pushOrConcat(base, toPush) { - if (toPush) { - if (isArray(toPush)) { - Array.prototype.push.apply(base, toPush); + this.width = this.right = maxWidth; + this.height = this.bottom = maxHeight; + const lineCount = isArray(opts.text) ? opts.text.length : 1; + this._padding = toPadding(opts.padding); + const textSize = lineCount * toFont(opts.font).lineHeight + this._padding.height; + if (this.isHorizontal()) { + this.height = textSize; + } else { + this.width = textSize; + } + } + isHorizontal() { + const pos = this.options.position; + return pos === 'top' || pos === 'bottom'; + } + _drawArgs(offset) { + const {top, left, bottom, right, options} = this; + const align = options.align; + let rotation = 0; + let maxWidth, titleX, titleY; + if (this.isHorizontal()) { + titleX = _alignStartEnd(align, left, right); + titleY = top + offset; + maxWidth = right - left; + } else { + if (options.position === 'left') { + titleX = left + offset; + titleY = _alignStartEnd(align, bottom, top); + rotation = PI * -0.5; } else { - base.push(toPush); + titleX = right - offset; + titleY = _alignStartEnd(align, top, bottom); + rotation = PI * 0.5; } + maxWidth = bottom - top; } - return base; + return {titleX, titleY, maxWidth, rotation}; } - function splitNewlines(str) { - if ((typeof str === 'string' || str instanceof String) && str.indexOf('\n') > -1) { - return str.split('\n'); + draw() { + const ctx = this.ctx; + const opts = this.options; + if (!opts.display) { + return; } - return str; - } - function createTooltipItem(chart, item) { - const element = item.element, - datasetIndex = item.datasetIndex, - index = item.index; - const controller = chart.getDatasetMeta(datasetIndex).controller; - const _controller$getLabelA = controller.getLabelAndValue(index), - label = _controller$getLabelA.label, - value = _controller$getLabelA.value; - return { - chart: chart, - label: label, - dataPoint: controller.getParsed(index), - formattedValue: value, - dataset: controller.getDataset(), - dataIndex: index, - datasetIndex: datasetIndex, - element: element - }; - } - function resolveOptions$1(options, fallbackFont) { - options = merge(Object.create(null), [defaults.plugins.tooltip, options]); - options.bodyFont = toFont(options.bodyFont, fallbackFont); - options.titleFont = toFont(options.titleFont, fallbackFont); - options.footerFont = toFont(options.footerFont, fallbackFont); - options.boxHeight = valueOrDefault(options.boxHeight, options.bodyFont.size); - options.boxWidth = valueOrDefault(options.boxWidth, options.bodyFont.size); - return options; - } - function getTooltipSize(tooltip) { - const ctx = tooltip._chart.ctx; - const body = tooltip.body, - footer = tooltip.footer, - options = tooltip.options, - title = tooltip.title; - const bodyFont = options.bodyFont, - footerFont = options.footerFont, - titleFont = options.titleFont, - boxWidth = options.boxWidth, - boxHeight = options.boxHeight; - const titleLineCount = title.length; - const footerLineCount = footer.length; - const bodyLineItemCount = body.length; - let height = options.yPadding * 2; - let width = 0; - let combinedBodyLength = body.reduce(function (count, bodyItem) { - return count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length; - }, 0); - combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length; - if (titleLineCount) { - height += titleLineCount * titleFont.size + (titleLineCount - 1) * options.titleSpacing + options.titleMarginBottom; - } - if (combinedBodyLength) { - const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.size) : bodyFont.size; - height += bodyLineItemCount * bodyLineHeight + (combinedBodyLength - bodyLineItemCount) * bodyFont.size + (combinedBodyLength - 1) * options.bodySpacing; - } - if (footerLineCount) { - height += options.footerMarginTop + footerLineCount * footerFont.size + (footerLineCount - 1) * options.footerSpacing; - } - let widthPadding = 0; - const maxLineWidth = function maxLineWidth(line) { - width = Math.max(width, ctx.measureText(line).width + widthPadding); - }; - ctx.save(); - ctx.font = titleFont.string; - each(tooltip.title, maxLineWidth); - ctx.font = bodyFont.string; - each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth); - widthPadding = options.displayColors ? boxWidth + 2 : 0; - each(body, function (bodyItem) { - each(bodyItem.before, maxLineWidth); - each(bodyItem.lines, maxLineWidth); - each(bodyItem.after, maxLineWidth); + const fontOpts = toFont(opts.font); + const lineHeight = fontOpts.lineHeight; + const offset = lineHeight / 2 + this._padding.top; + const {titleX, titleY, maxWidth, rotation} = this._drawArgs(offset); + renderText(ctx, opts.text, 0, 0, fontOpts, { + color: opts.color, + maxWidth, + rotation, + textAlign: _toLeftRightCenter(opts.align), + textBaseline: 'middle', + translation: [titleX, titleY], }); - widthPadding = 0; - ctx.font = footerFont.string; - each(tooltip.footer, maxLineWidth); - ctx.restore(); - width += 2 * options.xPadding; - return { - width: width, - height: height - }; } - function determineAlignment(chart, options, size) { - const x = size.x, - y = size.y, - width = size.width, - height = size.height; - const chartArea = chart.chartArea; - let xAlign = 'center'; - let yAlign = 'center'; - if (y < height / 2) { - yAlign = 'top'; - } else if (y > chart.height - height / 2) { - yAlign = 'bottom'; - } - let lf, rf; - const midX = (chartArea.left + chartArea.right) / 2; - const midY = (chartArea.top + chartArea.bottom) / 2; - if (yAlign === 'center') { - lf = function lf(value) { - return value <= midX; - }; - rf = function rf(value) { - return value > midX; - }; - } else { - lf = function lf(value) { - return value <= width / 2; - }; - rf = function rf(value) { - return value >= chart.width - width / 2; - }; +} +function createTitle(chart, titleOpts) { + const title = new Title({ + ctx: chart.ctx, + options: titleOpts, + chart + }); + layouts.configure(chart, title, titleOpts); + layouts.addBox(chart, title); + chart.titleBlock = title; +} +var plugin_title = { + id: 'title', + _element: Title, + start(chart, _args, options) { + createTitle(chart, options); + }, + stop(chart) { + const titleBlock = chart.titleBlock; + layouts.removeBox(chart, titleBlock); + delete chart.titleBlock; + }, + beforeUpdate(chart, _args, options) { + const title = chart.titleBlock; + layouts.configure(chart, title, options); + title.options = options; + }, + defaults: { + align: 'center', + display: false, + font: { + weight: 'bold', + }, + fullSize: true, + padding: 10, + position: 'top', + text: '', + weight: 2000 + }, + defaultRoutes: { + color: 'color' + }, + descriptors: { + _scriptable: true, + _indexable: false, + }, +}; + +const map = new WeakMap(); +var plugin_subtitle = { + id: 'subtitle', + start(chart, _args, options) { + const title = new Title({ + ctx: chart.ctx, + options, + chart + }); + layouts.configure(chart, title, options); + layouts.addBox(chart, title); + map.set(chart, title); + }, + stop(chart) { + layouts.removeBox(chart, map.get(chart)); + map.delete(chart); + }, + beforeUpdate(chart, _args, options) { + const title = map.get(chart); + layouts.configure(chart, title, options); + title.options = options; + }, + defaults: { + align: 'center', + display: false, + font: { + weight: 'normal', + }, + fullSize: true, + padding: 0, + position: 'top', + text: '', + weight: 1500 + }, + defaultRoutes: { + color: 'color' + }, + descriptors: { + _scriptable: true, + _indexable: false, + }, +}; + +const positioners = { + average(items) { + if (!items.length) { + return false; } - const olf = function olf(value) { - return value + width + options.caretSize + options.caretPadding > chart.width; - }; - const orf = function orf(value) { - return value - width - options.caretSize - options.caretPadding < 0; - }; - const yf = function yf(value) { - return value <= midY ? 'top' : 'bottom'; - }; - if (lf(x)) { - xAlign = 'left'; - if (olf(x)) { - xAlign = 'center'; - yAlign = yf(y); - } - } else if (rf(x)) { - xAlign = 'right'; - if (orf(x)) { - xAlign = 'center'; - yAlign = yf(y); + let i, len; + let x = 0; + let y = 0; + let count = 0; + for (i = 0, len = items.length; i < len; ++i) { + const el = items[i].element; + if (el && el.hasValue()) { + const pos = el.tooltipPosition(); + x += pos.x; + y += pos.y; + ++count; } } return { - xAlign: options.xAlign ? options.xAlign : xAlign, - yAlign: options.yAlign ? options.yAlign : yAlign + x: x / count, + y: y / count }; - } - function alignX(size, xAlign, chartWidth) { - let x = size.x, - width = size.width; - if (xAlign === 'right') { - x -= width; - } else if (xAlign === 'center') { - x -= width / 2; - if (x + width > chartWidth) { - x = chartWidth - width; - } - if (x < 0) { - x = 0; - } + }, + nearest(items, eventPosition) { + if (!items.length) { + return false; } - return x; - } - function alignY(size, yAlign, paddingAndSize) { - let y = size.y, - height = size.height; - if (yAlign === 'top') { - y += paddingAndSize; - } else if (yAlign === 'bottom') { - y -= height + paddingAndSize; - } else { - y -= height / 2; - } - return y; - } - function getBackgroundPoint(options, size, alignment, chart) { - const caretSize = options.caretSize, - caretPadding = options.caretPadding, - cornerRadius = options.cornerRadius; - const xAlign = alignment.xAlign, - yAlign = alignment.yAlign; - const paddingAndSize = caretSize + caretPadding; - const radiusAndPadding = cornerRadius + caretPadding; - let x = alignX(size, xAlign, chart.width); - const y = alignY(size, yAlign, paddingAndSize); - if (yAlign === 'center') { - if (xAlign === 'left') { - x += paddingAndSize; - } else if (xAlign === 'right') { - x -= paddingAndSize; + let x = eventPosition.x; + let y = eventPosition.y; + let minDistance = Number.POSITIVE_INFINITY; + let i, len, nearestElement; + for (i = 0, len = items.length; i < len; ++i) { + const el = items[i].element; + if (el && el.hasValue()) { + const center = el.getCenterPoint(); + const d = distanceBetweenPoints(eventPosition, center); + if (d < minDistance) { + minDistance = d; + nearestElement = el; + } } - } else if (xAlign === 'left') { - x -= radiusAndPadding; - } else if (xAlign === 'right') { - x += radiusAndPadding; + } + if (nearestElement) { + const tp = nearestElement.tooltipPosition(); + x = tp.x; + y = tp.y; } return { - x: x, - y: y + x, + y }; } - function getAlignedX(tooltip, align) { - const options = tooltip.options; - return align === 'center' ? tooltip.x + tooltip.width / 2 : align === 'right' ? tooltip.x + tooltip.width - options.xPadding : tooltip.x + options.xPadding; - } - function getBeforeAfterBodyLines(callback) { - return pushOrConcat([], splitNewlines(callback)); - } - const Tooltip = function (_Element) { - _inheritsLoose(Tooltip, _Element); - function Tooltip(config) { - let _this; - _this = _Element.call(this) || this; - _this.opacity = 0; - _this._active = []; - _this._chart = config._chart; - _this._eventPosition = undefined; - _this._size = undefined; - _this._cachedAnimations = undefined; - _this.$animations = undefined; - _this.options = undefined; - _this.dataPoints = undefined; - _this.title = undefined; - _this.beforeBody = undefined; - _this.body = undefined; - _this.afterBody = undefined; - _this.footer = undefined; - _this.xAlign = undefined; - _this.yAlign = undefined; - _this.x = undefined; - _this.y = undefined; - _this.height = undefined; - _this.width = undefined; - _this.caretX = undefined; - _this.caretY = undefined; - _this.labelColors = undefined; - _this.labelPointStyles = undefined; - _this.labelTextColors = undefined; - _this.initialize(); - return _this; - } - const _proto = Tooltip.prototype; - _proto.initialize = function initialize() { - const me = this; - const chartOpts = me._chart.options; - me.options = resolveOptions$1(chartOpts.tooltips, chartOpts.font); - me._cachedAnimations = undefined; - } - ; - _proto._resolveAnimations = function _resolveAnimations() { - const me = this; - const cached = me._cachedAnimations; - if (cached) { - return cached; - } - const chart = me._chart; - const options = me.options; - const opts = options.enabled && chart.options.animation && options.animation; - const animations = new Animations(me._chart, opts); - me._cachedAnimations = Object.freeze(animations); - return animations; - }; - _proto.getTitle = function getTitle(context) { - const me = this; - const opts = me.options; - const callbacks = opts.callbacks; - const beforeTitle = callbacks.beforeTitle.apply(me, [context]); - const title = callbacks.title.apply(me, [context]); - const afterTitle = callbacks.afterTitle.apply(me, [context]); - let lines = []; - lines = pushOrConcat(lines, splitNewlines(beforeTitle)); - lines = pushOrConcat(lines, splitNewlines(title)); - lines = pushOrConcat(lines, splitNewlines(afterTitle)); - return lines; - }; - _proto.getBeforeBody = function getBeforeBody(tooltipItems) { - return getBeforeAfterBodyLines(this.options.callbacks.beforeBody.apply(this, [tooltipItems])); - }; - _proto.getBody = function getBody(tooltipItems) { - const me = this; - const callbacks = me.options.callbacks; - const bodyItems = []; - each(tooltipItems, function (context) { - const bodyItem = { - before: [], - lines: [], - after: [] - }; - pushOrConcat(bodyItem.before, splitNewlines(callbacks.beforeLabel.call(me, context))); - pushOrConcat(bodyItem.lines, callbacks.label.call(me, context)); - pushOrConcat(bodyItem.after, splitNewlines(callbacks.afterLabel.call(me, context))); - bodyItems.push(bodyItem); - }); - return bodyItems; - }; - _proto.getAfterBody = function getAfterBody(tooltipItems) { - return getBeforeAfterBodyLines(this.options.callbacks.afterBody.apply(this, [tooltipItems])); - } - ; - _proto.getFooter = function getFooter(tooltipItems) { - const me = this; - const callbacks = me.options.callbacks; - const beforeFooter = callbacks.beforeFooter.apply(me, [tooltipItems]); - const footer = callbacks.footer.apply(me, [tooltipItems]); - const afterFooter = callbacks.afterFooter.apply(me, [tooltipItems]); - let lines = []; - lines = pushOrConcat(lines, splitNewlines(beforeFooter)); - lines = pushOrConcat(lines, splitNewlines(footer)); - lines = pushOrConcat(lines, splitNewlines(afterFooter)); - return lines; - } - ; - _proto._createItems = function _createItems() { - const me = this; - const active = me._active; - const options = me.options; - const data = me._chart.data; - const labelColors = []; - const labelPointStyles = []; - const labelTextColors = []; - let tooltipItems = []; - let i, len; - for (i = 0, len = active.length; i < len; ++i) { - tooltipItems.push(createTooltipItem(me._chart, active[i])); - } - if (options.filter) { - tooltipItems = tooltipItems.filter(function (element, index, array) { - return options.filter(element, index, array, data); - }); - } - if (options.itemSort) { - tooltipItems = tooltipItems.sort(function (a, b) { - return options.itemSort(a, b, data); - }); - } - each(tooltipItems, function (context) { - labelColors.push(options.callbacks.labelColor.call(me, context)); - labelPointStyles.push(options.callbacks.labelPointStyle.call(me, context)); - labelTextColors.push(options.callbacks.labelTextColor.call(me, context)); - }); - me.labelColors = labelColors; - me.labelPointStyles = labelPointStyles; - me.labelTextColors = labelTextColors; - me.dataPoints = tooltipItems; - return tooltipItems; - }; - _proto.update = function update(changed) { - const me = this; - const options = me.options; - const active = me._active; - let properties; - if (!active.length) { - if (me.opacity !== 0) { - properties = { - opacity: 0 - }; - } - } else { - const position = positioners[options.position].call(me, active, me._eventPosition); - const tooltipItems = me._createItems(); - me.title = me.getTitle(tooltipItems); - me.beforeBody = me.getBeforeBody(tooltipItems); - me.body = me.getBody(tooltipItems); - me.afterBody = me.getAfterBody(tooltipItems); - me.footer = me.getFooter(tooltipItems); - const size = me._size = getTooltipSize(me); - const positionAndSize = _extends({}, position, size); - const alignment = determineAlignment(me._chart, options, positionAndSize); - const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, me._chart); - me.xAlign = alignment.xAlign; - me.yAlign = alignment.yAlign; +}; +function pushOrConcat(base, toPush) { + if (toPush) { + if (isArray(toPush)) { + Array.prototype.push.apply(base, toPush); + } else { + base.push(toPush); + } + } + return base; +} +function splitNewlines(str) { + if ((typeof str === 'string' || str instanceof String) && str.indexOf('\n') > -1) { + return str.split('\n'); + } + return str; +} +function createTooltipItem(chart, item) { + const {element, datasetIndex, index} = item; + const controller = chart.getDatasetMeta(datasetIndex).controller; + const {label, value} = controller.getLabelAndValue(index); + return { + chart, + label, + parsed: controller.getParsed(index), + raw: chart.data.datasets[datasetIndex].data[index], + formattedValue: value, + dataset: controller.getDataset(), + dataIndex: index, + datasetIndex, + element + }; +} +function getTooltipSize(tooltip, options) { + const ctx = tooltip.chart.ctx; + const {body, footer, title} = tooltip; + const {boxWidth, boxHeight} = options; + const bodyFont = toFont(options.bodyFont); + const titleFont = toFont(options.titleFont); + const footerFont = toFont(options.footerFont); + const titleLineCount = title.length; + const footerLineCount = footer.length; + const bodyLineItemCount = body.length; + const padding = toPadding(options.padding); + let height = padding.height; + let width = 0; + let combinedBodyLength = body.reduce((count, bodyItem) => count + bodyItem.before.length + bodyItem.lines.length + bodyItem.after.length, 0); + combinedBodyLength += tooltip.beforeBody.length + tooltip.afterBody.length; + if (titleLineCount) { + height += titleLineCount * titleFont.lineHeight + + (titleLineCount - 1) * options.titleSpacing + + options.titleMarginBottom; + } + if (combinedBodyLength) { + const bodyLineHeight = options.displayColors ? Math.max(boxHeight, bodyFont.lineHeight) : bodyFont.lineHeight; + height += bodyLineItemCount * bodyLineHeight + + (combinedBodyLength - bodyLineItemCount) * bodyFont.lineHeight + + (combinedBodyLength - 1) * options.bodySpacing; + } + if (footerLineCount) { + height += options.footerMarginTop + + footerLineCount * footerFont.lineHeight + + (footerLineCount - 1) * options.footerSpacing; + } + let widthPadding = 0; + const maxLineWidth = function(line) { + width = Math.max(width, ctx.measureText(line).width + widthPadding); + }; + ctx.save(); + ctx.font = titleFont.string; + each(tooltip.title, maxLineWidth); + ctx.font = bodyFont.string; + each(tooltip.beforeBody.concat(tooltip.afterBody), maxLineWidth); + widthPadding = options.displayColors ? (boxWidth + 2 + options.boxPadding) : 0; + each(body, (bodyItem) => { + each(bodyItem.before, maxLineWidth); + each(bodyItem.lines, maxLineWidth); + each(bodyItem.after, maxLineWidth); + }); + widthPadding = 0; + ctx.font = footerFont.string; + each(tooltip.footer, maxLineWidth); + ctx.restore(); + width += padding.width; + return {width, height}; +} +function determineYAlign(chart, size) { + const {y, height} = size; + if (y < height / 2) { + return 'top'; + } else if (y > (chart.height - height / 2)) { + return 'bottom'; + } + return 'center'; +} +function doesNotFitWithAlign(xAlign, chart, options, size) { + const {x, width} = size; + const caret = options.caretSize + options.caretPadding; + if (xAlign === 'left' && x + width + caret > chart.width) { + return true; + } + if (xAlign === 'right' && x - width - caret < 0) { + return true; + } +} +function determineXAlign(chart, options, size, yAlign) { + const {x, width} = size; + const {width: chartWidth, chartArea: {left, right}} = chart; + let xAlign = 'center'; + if (yAlign === 'center') { + xAlign = x <= (left + right) / 2 ? 'left' : 'right'; + } else if (x <= width / 2) { + xAlign = 'left'; + } else if (x >= chartWidth - width / 2) { + xAlign = 'right'; + } + if (doesNotFitWithAlign(xAlign, chart, options, size)) { + xAlign = 'center'; + } + return xAlign; +} +function determineAlignment(chart, options, size) { + const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size); + return { + xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign), + yAlign + }; +} +function alignX(size, xAlign) { + let {x, width} = size; + if (xAlign === 'right') { + x -= width; + } else if (xAlign === 'center') { + x -= (width / 2); + } + return x; +} +function alignY(size, yAlign, paddingAndSize) { + let {y, height} = size; + if (yAlign === 'top') { + y += paddingAndSize; + } else if (yAlign === 'bottom') { + y -= height + paddingAndSize; + } else { + y -= (height / 2); + } + return y; +} +function getBackgroundPoint(options, size, alignment, chart) { + const {caretSize, caretPadding, cornerRadius} = options; + const {xAlign, yAlign} = alignment; + const paddingAndSize = caretSize + caretPadding; + const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius); + let x = alignX(size, xAlign); + const y = alignY(size, yAlign, paddingAndSize); + if (yAlign === 'center') { + if (xAlign === 'left') { + x += paddingAndSize; + } else if (xAlign === 'right') { + x -= paddingAndSize; + } + } else if (xAlign === 'left') { + x -= Math.max(topLeft, bottomLeft) + caretSize; + } else if (xAlign === 'right') { + x += Math.max(topRight, bottomRight) + caretSize; + } + return { + x: _limitValue(x, 0, chart.width - size.width), + y: _limitValue(y, 0, chart.height - size.height) + }; +} +function getAlignedX(tooltip, align, options) { + const padding = toPadding(options.padding); + return align === 'center' + ? tooltip.x + tooltip.width / 2 + : align === 'right' + ? tooltip.x + tooltip.width - padding.right + : tooltip.x + padding.left; +} +function getBeforeAfterBodyLines(callback) { + return pushOrConcat([], splitNewlines(callback)); +} +function createTooltipContext(parent, tooltip, tooltipItems) { + return createContext(parent, { + tooltip, + tooltipItems, + type: 'tooltip' + }); +} +function overrideCallbacks(callbacks, context) { + const override = context && context.dataset && context.dataset.tooltip && context.dataset.tooltip.callbacks; + return override ? callbacks.override(override) : callbacks; +} +class Tooltip extends Element { + constructor(config) { + super(); + this.opacity = 0; + this._active = []; + this._eventPosition = undefined; + this._size = undefined; + this._cachedAnimations = undefined; + this._tooltipItems = []; + this.$animations = undefined; + this.$context = undefined; + this.chart = config.chart || config._chart; + this._chart = this.chart; + this.options = config.options; + this.dataPoints = undefined; + this.title = undefined; + this.beforeBody = undefined; + this.body = undefined; + this.afterBody = undefined; + this.footer = undefined; + this.xAlign = undefined; + this.yAlign = undefined; + this.x = undefined; + this.y = undefined; + this.height = undefined; + this.width = undefined; + this.caretX = undefined; + this.caretY = undefined; + this.labelColors = undefined; + this.labelPointStyles = undefined; + this.labelTextColors = undefined; + } + initialize(options) { + this.options = options; + this._cachedAnimations = undefined; + this.$context = undefined; + } + _resolveAnimations() { + const cached = this._cachedAnimations; + if (cached) { + return cached; + } + const chart = this.chart; + const options = this.options.setContext(this.getContext()); + const opts = options.enabled && chart.options.animation && options.animations; + const animations = new Animations(this.chart, opts); + if (opts._cacheable) { + this._cachedAnimations = Object.freeze(animations); + } + return animations; + } + getContext() { + return this.$context || + (this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems)); + } + getTitle(context, options) { + const {callbacks} = options; + const beforeTitle = callbacks.beforeTitle.apply(this, [context]); + const title = callbacks.title.apply(this, [context]); + const afterTitle = callbacks.afterTitle.apply(this, [context]); + let lines = []; + lines = pushOrConcat(lines, splitNewlines(beforeTitle)); + lines = pushOrConcat(lines, splitNewlines(title)); + lines = pushOrConcat(lines, splitNewlines(afterTitle)); + return lines; + } + getBeforeBody(tooltipItems, options) { + return getBeforeAfterBodyLines(options.callbacks.beforeBody.apply(this, [tooltipItems])); + } + getBody(tooltipItems, options) { + const {callbacks} = options; + const bodyItems = []; + each(tooltipItems, (context) => { + const bodyItem = { + before: [], + lines: [], + after: [] + }; + const scoped = overrideCallbacks(callbacks, context); + pushOrConcat(bodyItem.before, splitNewlines(scoped.beforeLabel.call(this, context))); + pushOrConcat(bodyItem.lines, scoped.label.call(this, context)); + pushOrConcat(bodyItem.after, splitNewlines(scoped.afterLabel.call(this, context))); + bodyItems.push(bodyItem); + }); + return bodyItems; + } + getAfterBody(tooltipItems, options) { + return getBeforeAfterBodyLines(options.callbacks.afterBody.apply(this, [tooltipItems])); + } + getFooter(tooltipItems, options) { + const {callbacks} = options; + const beforeFooter = callbacks.beforeFooter.apply(this, [tooltipItems]); + const footer = callbacks.footer.apply(this, [tooltipItems]); + const afterFooter = callbacks.afterFooter.apply(this, [tooltipItems]); + let lines = []; + lines = pushOrConcat(lines, splitNewlines(beforeFooter)); + lines = pushOrConcat(lines, splitNewlines(footer)); + lines = pushOrConcat(lines, splitNewlines(afterFooter)); + return lines; + } + _createItems(options) { + const active = this._active; + const data = this.chart.data; + const labelColors = []; + const labelPointStyles = []; + const labelTextColors = []; + let tooltipItems = []; + let i, len; + for (i = 0, len = active.length; i < len; ++i) { + tooltipItems.push(createTooltipItem(this.chart, active[i])); + } + if (options.filter) { + tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data)); + } + if (options.itemSort) { + tooltipItems = tooltipItems.sort((a, b) => options.itemSort(a, b, data)); + } + each(tooltipItems, (context) => { + const scoped = overrideCallbacks(options.callbacks, context); + labelColors.push(scoped.labelColor.call(this, context)); + labelPointStyles.push(scoped.labelPointStyle.call(this, context)); + labelTextColors.push(scoped.labelTextColor.call(this, context)); + }); + this.labelColors = labelColors; + this.labelPointStyles = labelPointStyles; + this.labelTextColors = labelTextColors; + this.dataPoints = tooltipItems; + return tooltipItems; + } + update(changed, replay) { + const options = this.options.setContext(this.getContext()); + const active = this._active; + let properties; + let tooltipItems = []; + if (!active.length) { + if (this.opacity !== 0) { properties = { - opacity: 1, - x: backgroundPoint.x, - y: backgroundPoint.y, - width: size.width, - height: size.height, - caretX: position.x, - caretY: position.y + opacity: 0 }; } - if (properties) { - me._resolveAnimations().update(me, properties); - } - if (changed && options.custom) { - options.custom.call(me, { - chart: me._chart, - tooltip: me - }); + } else { + const position = positioners[options.position].call(this, active, this._eventPosition); + tooltipItems = this._createItems(options); + this.title = this.getTitle(tooltipItems, options); + this.beforeBody = this.getBeforeBody(tooltipItems, options); + this.body = this.getBody(tooltipItems, options); + this.afterBody = this.getAfterBody(tooltipItems, options); + this.footer = this.getFooter(tooltipItems, options); + const size = this._size = getTooltipSize(this, options); + const positionAndSize = Object.assign({}, position, size); + const alignment = determineAlignment(this.chart, options, positionAndSize); + const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart); + this.xAlign = alignment.xAlign; + this.yAlign = alignment.yAlign; + properties = { + opacity: 1, + x: backgroundPoint.x, + y: backgroundPoint.y, + width: size.width, + height: size.height, + caretX: position.x, + caretY: position.y + }; + } + this._tooltipItems = tooltipItems; + this.$context = undefined; + if (properties) { + this._resolveAnimations().update(this, properties); + } + if (changed && options.external) { + options.external.call(this, {chart: this.chart, tooltip: this, replay}); + } + } + drawCaret(tooltipPoint, ctx, size, options) { + const caretPosition = this.getCaretPosition(tooltipPoint, size, options); + ctx.lineTo(caretPosition.x1, caretPosition.y1); + ctx.lineTo(caretPosition.x2, caretPosition.y2); + ctx.lineTo(caretPosition.x3, caretPosition.y3); + } + getCaretPosition(tooltipPoint, size, options) { + const {xAlign, yAlign} = this; + const {caretSize, cornerRadius} = options; + const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(cornerRadius); + const {x: ptX, y: ptY} = tooltipPoint; + const {width, height} = size; + let x1, x2, x3, y1, y2, y3; + if (yAlign === 'center') { + y2 = ptY + (height / 2); + if (xAlign === 'left') { + x1 = ptX; + x2 = x1 - caretSize; + y1 = y2 + caretSize; + y3 = y2 - caretSize; + } else { + x1 = ptX + width; + x2 = x1 + caretSize; + y1 = y2 - caretSize; + y3 = y2 + caretSize; } - }; - _proto.drawCaret = function drawCaret(tooltipPoint, ctx, size) { - const caretPosition = this.getCaretPosition(tooltipPoint, size); - ctx.lineTo(caretPosition.x1, caretPosition.y1); - ctx.lineTo(caretPosition.x2, caretPosition.y2); - ctx.lineTo(caretPosition.x3, caretPosition.y3); - }; - _proto.getCaretPosition = function getCaretPosition(tooltipPoint, size) { - const xAlign = this.xAlign, - yAlign = this.yAlign, - options = this.options; - const cornerRadius = options.cornerRadius, - caretSize = options.caretSize; - const ptX = tooltipPoint.x, - ptY = tooltipPoint.y; - const width = size.width, - height = size.height; - let x1, x2, x3, y1, y2, y3; - if (yAlign === 'center') { - y2 = ptY + height / 2; - if (xAlign === 'left') { - x1 = ptX; - x2 = x1 - caretSize; - y1 = y2 + caretSize; - y3 = y2 - caretSize; - } else { - x1 = ptX + width; - x2 = x1 + caretSize; - y1 = y2 - caretSize; - y3 = y2 + caretSize; - } - x3 = x1; + x3 = x1; + } else { + if (xAlign === 'left') { + x2 = ptX + Math.max(topLeft, bottomLeft) + (caretSize); + } else if (xAlign === 'right') { + x2 = ptX + width - Math.max(topRight, bottomRight) - caretSize; } else { - if (xAlign === 'left') { - x2 = ptX + cornerRadius + caretSize; - } else if (xAlign === 'right') { - x2 = ptX + width - cornerRadius - caretSize; - } else { - x2 = this.caretX; - } - if (yAlign === 'top') { - y1 = ptY; - y2 = y1 - caretSize; - x1 = x2 - caretSize; - x3 = x2 + caretSize; - } else { - y1 = ptY + height; - y2 = y1 + caretSize; - x1 = x2 + caretSize; - x3 = x2 - caretSize; - } - y3 = y1; + x2 = this.caretX; } - return { - x1: x1, - x2: x2, - x3: x3, - y1: y1, - y2: y2, - y3: y3 + if (yAlign === 'top') { + y1 = ptY; + y2 = y1 - caretSize; + x1 = x2 - caretSize; + x3 = x2 + caretSize; + } else { + y1 = ptY + height; + y2 = y1 + caretSize; + x1 = x2 + caretSize; + x3 = x2 - caretSize; + } + y3 = y1; + } + return {x1, x2, x3, y1, y2, y3}; + } + drawTitle(pt, ctx, options) { + const title = this.title; + const length = title.length; + let titleFont, titleSpacing, i; + if (length) { + const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width); + pt.x = getAlignedX(this, options.titleAlign, options); + ctx.textAlign = rtlHelper.textAlign(options.titleAlign); + ctx.textBaseline = 'middle'; + titleFont = toFont(options.titleFont); + titleSpacing = options.titleSpacing; + ctx.fillStyle = options.titleColor; + ctx.font = titleFont.string; + for (i = 0; i < length; ++i) { + ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.lineHeight / 2); + pt.y += titleFont.lineHeight + titleSpacing; + if (i + 1 === length) { + pt.y += options.titleMarginBottom - titleSpacing; + } + } + } + } + _drawColorBox(ctx, pt, i, rtlHelper, options) { + const labelColors = this.labelColors[i]; + const labelPointStyle = this.labelPointStyles[i]; + const {boxHeight, boxWidth, boxPadding} = options; + const bodyFont = toFont(options.bodyFont); + const colorX = getAlignedX(this, 'left', options); + const rtlColorX = rtlHelper.x(colorX); + const yOffSet = boxHeight < bodyFont.lineHeight ? (bodyFont.lineHeight - boxHeight) / 2 : 0; + const colorY = pt.y + yOffSet; + if (options.usePointStyle) { + const drawOptions = { + radius: Math.min(boxWidth, boxHeight) / 2, + pointStyle: labelPointStyle.pointStyle, + rotation: labelPointStyle.rotation, + borderWidth: 1 }; - }; - _proto.drawTitle = function drawTitle(pt, ctx) { - const me = this; - const options = me.options; - const title = me.title; - const length = title.length; - let titleFont, titleSpacing, i; - if (length) { - const rtlHelper = getRtlAdapter(options.rtl, me.x, me.width); - pt.x = getAlignedX(me, options.titleAlign); - ctx.textAlign = rtlHelper.textAlign(options.titleAlign); - ctx.textBaseline = 'middle'; - titleFont = options.titleFont; - titleSpacing = options.titleSpacing; - ctx.fillStyle = options.titleFont.color; - ctx.font = titleFont.string; - for (i = 0; i < length; ++i) { - ctx.fillText(title[i], rtlHelper.x(pt.x), pt.y + titleFont.size / 2); - pt.y += titleFont.size + titleSpacing; - if (i + 1 === length) { - pt.y += options.titleMarginBottom - titleSpacing; - } - } - } - } - ; - _proto._drawColorBox = function _drawColorBox(ctx, pt, i, rtlHelper) { - const me = this; - const options = me.options; - const labelColors = me.labelColors[i]; - const labelPointStyle = me.labelPointStyles[i]; - const boxHeight = options.boxHeight, - boxWidth = options.boxWidth, - bodyFont = options.bodyFont; - const colorX = getAlignedX(me, 'left'); - const rtlColorX = rtlHelper.x(colorX); - const yOffSet = boxHeight < bodyFont.size ? (bodyFont.size - boxHeight) / 2 : 0; - const colorY = pt.y + yOffSet; - if (options.usePointStyle) { - const drawOptions = { - radius: Math.min(boxWidth, boxHeight) / 2, - pointStyle: labelPointStyle.pointStyle, - rotation: labelPointStyle.rotation, - borderWidth: 1 - }; - const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2; - const centerY = colorY + boxHeight / 2; - ctx.strokeStyle = options.multiKeyBackground; + const centerX = rtlHelper.leftForLtr(rtlColorX, boxWidth) + boxWidth / 2; + const centerY = colorY + boxHeight / 2; + ctx.strokeStyle = options.multiKeyBackground; + ctx.fillStyle = options.multiKeyBackground; + drawPoint(ctx, drawOptions, centerX, centerY); + ctx.strokeStyle = labelColors.borderColor; + ctx.fillStyle = labelColors.backgroundColor; + drawPoint(ctx, drawOptions, centerX, centerY); + } else { + ctx.lineWidth = isObject(labelColors.borderWidth) ? Math.max(...Object.values(labelColors.borderWidth)) : (labelColors.borderWidth || 1); + ctx.strokeStyle = labelColors.borderColor; + ctx.setLineDash(labelColors.borderDash || []); + ctx.lineDashOffset = labelColors.borderDashOffset || 0; + const outerX = rtlHelper.leftForLtr(rtlColorX, boxWidth - boxPadding); + const innerX = rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - boxPadding - 2); + const borderRadius = toTRBLCorners(labelColors.borderRadius); + if (Object.values(borderRadius).some(v => v !== 0)) { + ctx.beginPath(); ctx.fillStyle = options.multiKeyBackground; - drawPoint(ctx, drawOptions, centerX, centerY); - ctx.strokeStyle = labelColors.borderColor; + addRoundedRectPath(ctx, { + x: outerX, + y: colorY, + w: boxWidth, + h: boxHeight, + radius: borderRadius, + }); + ctx.fill(); + ctx.stroke(); ctx.fillStyle = labelColors.backgroundColor; - drawPoint(ctx, drawOptions, centerX, centerY); + ctx.beginPath(); + addRoundedRectPath(ctx, { + x: innerX, + y: colorY + 1, + w: boxWidth - 2, + h: boxHeight - 2, + radius: borderRadius, + }); + ctx.fill(); } else { ctx.fillStyle = options.multiKeyBackground; - ctx.fillRect(rtlHelper.leftForLtr(rtlColorX, boxWidth), colorY, boxWidth, boxHeight); - ctx.lineWidth = 1; - ctx.strokeStyle = labelColors.borderColor; - ctx.strokeRect(rtlHelper.leftForLtr(rtlColorX, boxWidth), colorY, boxWidth, boxHeight); + ctx.fillRect(outerX, colorY, boxWidth, boxHeight); + ctx.strokeRect(outerX, colorY, boxWidth, boxHeight); ctx.fillStyle = labelColors.backgroundColor; - ctx.fillRect(rtlHelper.leftForLtr(rtlHelper.xPlus(rtlColorX, 1), boxWidth - 2), colorY + 1, boxWidth - 2, boxHeight - 2); + ctx.fillRect(innerX, colorY + 1, boxWidth - 2, boxHeight - 2); } - ctx.fillStyle = me.labelTextColors[i]; + } + ctx.fillStyle = this.labelTextColors[i]; + } + drawBody(pt, ctx, options) { + const {body} = this; + const {bodySpacing, bodyAlign, displayColors, boxHeight, boxWidth, boxPadding} = options; + const bodyFont = toFont(options.bodyFont); + let bodyLineHeight = bodyFont.lineHeight; + let xLinePadding = 0; + const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width); + const fillLineOfText = function(line) { + ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2); + pt.y += bodyLineHeight + bodySpacing; }; - _proto.drawBody = function drawBody(pt, ctx) { - const me = this; - const body = me.body, - options = me.options; - const bodyFont = options.bodyFont, - bodySpacing = options.bodySpacing, - bodyAlign = options.bodyAlign, - displayColors = options.displayColors, - boxHeight = options.boxHeight, - boxWidth = options.boxWidth; - let bodyLineHeight = bodyFont.size; - let xLinePadding = 0; - const rtlHelper = getRtlAdapter(options.rtl, me.x, me.width); - const fillLineOfText = function fillLineOfText(line) { - ctx.fillText(line, rtlHelper.x(pt.x + xLinePadding), pt.y + bodyLineHeight / 2); - pt.y += bodyLineHeight + bodySpacing; - }; - const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign); - let bodyItem, textColor, lines, i, j, ilen, jlen; - ctx.textAlign = bodyAlign; + const bodyAlignForCalculation = rtlHelper.textAlign(bodyAlign); + let bodyItem, textColor, lines, i, j, ilen, jlen; + ctx.textAlign = bodyAlign; + ctx.textBaseline = 'middle'; + ctx.font = bodyFont.string; + pt.x = getAlignedX(this, bodyAlignForCalculation, options); + ctx.fillStyle = options.bodyColor; + each(this.beforeBody, fillLineOfText); + xLinePadding = displayColors && bodyAlignForCalculation !== 'right' + ? bodyAlign === 'center' ? (boxWidth / 2 + boxPadding) : (boxWidth + 2 + boxPadding) + : 0; + for (i = 0, ilen = body.length; i < ilen; ++i) { + bodyItem = body[i]; + textColor = this.labelTextColors[i]; + ctx.fillStyle = textColor; + each(bodyItem.before, fillLineOfText); + lines = bodyItem.lines; + if (displayColors && lines.length) { + this._drawColorBox(ctx, pt, i, rtlHelper, options); + bodyLineHeight = Math.max(bodyFont.lineHeight, boxHeight); + } + for (j = 0, jlen = lines.length; j < jlen; ++j) { + fillLineOfText(lines[j]); + bodyLineHeight = bodyFont.lineHeight; + } + each(bodyItem.after, fillLineOfText); + } + xLinePadding = 0; + bodyLineHeight = bodyFont.lineHeight; + each(this.afterBody, fillLineOfText); + pt.y -= bodySpacing; + } + drawFooter(pt, ctx, options) { + const footer = this.footer; + const length = footer.length; + let footerFont, i; + if (length) { + const rtlHelper = getRtlAdapter(options.rtl, this.x, this.width); + pt.x = getAlignedX(this, options.footerAlign, options); + pt.y += options.footerMarginTop; + ctx.textAlign = rtlHelper.textAlign(options.footerAlign); ctx.textBaseline = 'middle'; - ctx.font = bodyFont.string; - pt.x = getAlignedX(me, bodyAlignForCalculation); - ctx.fillStyle = bodyFont.color; - each(me.beforeBody, fillLineOfText); - xLinePadding = displayColors && bodyAlignForCalculation !== 'right' ? bodyAlign === 'center' ? boxWidth / 2 + 1 : boxWidth + 2 : 0; - for (i = 0, ilen = body.length; i < ilen; ++i) { - bodyItem = body[i]; - textColor = me.labelTextColors[i]; - ctx.fillStyle = textColor; - each(bodyItem.before, fillLineOfText); - lines = bodyItem.lines; - if (displayColors && lines.length) { - me._drawColorBox(ctx, pt, i, rtlHelper); - bodyLineHeight = Math.max(bodyFont.size, boxHeight); - } - for (j = 0, jlen = lines.length; j < jlen; ++j) { - fillLineOfText(lines[j]); - bodyLineHeight = bodyFont.size; - } - each(bodyItem.after, fillLineOfText); - } - xLinePadding = 0; - bodyLineHeight = bodyFont.size; - each(me.afterBody, fillLineOfText); - pt.y -= bodySpacing; - }; - _proto.drawFooter = function drawFooter(pt, ctx) { - const me = this; - const options = me.options; - const footer = me.footer; - const length = footer.length; - let footerFont, i; - if (length) { - const rtlHelper = getRtlAdapter(options.rtl, me.x, me.width); - pt.x = getAlignedX(me, options.footerAlign); - pt.y += options.footerMarginTop; - ctx.textAlign = rtlHelper.textAlign(options.footerAlign); - ctx.textBaseline = 'middle'; - footerFont = options.footerFont; - ctx.fillStyle = options.footerFont.color; - ctx.font = footerFont.string; - for (i = 0; i < length; ++i) { - ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.size / 2); - pt.y += footerFont.size + options.footerSpacing; - } - } - }; - _proto.drawBackground = function drawBackground(pt, ctx, tooltipSize) { - const xAlign = this.xAlign, - yAlign = this.yAlign, - options = this.options; - const x = pt.x, - y = pt.y; - const width = tooltipSize.width, - height = tooltipSize.height; - const radius = options.cornerRadius; - ctx.fillStyle = options.backgroundColor; - ctx.strokeStyle = options.borderColor; - ctx.lineWidth = options.borderWidth; - ctx.beginPath(); - ctx.moveTo(x + radius, y); - if (yAlign === 'top') { - this.drawCaret(pt, ctx, tooltipSize); - } - ctx.lineTo(x + width - radius, y); - ctx.quadraticCurveTo(x + width, y, x + width, y + radius); - if (yAlign === 'center' && xAlign === 'right') { - this.drawCaret(pt, ctx, tooltipSize); - } - ctx.lineTo(x + width, y + height - radius); - ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height); - if (yAlign === 'bottom') { - this.drawCaret(pt, ctx, tooltipSize); + footerFont = toFont(options.footerFont); + ctx.fillStyle = options.footerColor; + ctx.font = footerFont.string; + for (i = 0; i < length; ++i) { + ctx.fillText(footer[i], rtlHelper.x(pt.x), pt.y + footerFont.lineHeight / 2); + pt.y += footerFont.lineHeight + options.footerSpacing; } - ctx.lineTo(x + radius, y + height); - ctx.quadraticCurveTo(x, y + height, x, y + height - radius); - if (yAlign === 'center' && xAlign === 'left') { - this.drawCaret(pt, ctx, tooltipSize); + } + } + drawBackground(pt, ctx, tooltipSize, options) { + const {xAlign, yAlign} = this; + const {x, y} = pt; + const {width, height} = tooltipSize; + const {topLeft, topRight, bottomLeft, bottomRight} = toTRBLCorners(options.cornerRadius); + ctx.fillStyle = options.backgroundColor; + ctx.strokeStyle = options.borderColor; + ctx.lineWidth = options.borderWidth; + ctx.beginPath(); + ctx.moveTo(x + topLeft, y); + if (yAlign === 'top') { + this.drawCaret(pt, ctx, tooltipSize, options); + } + ctx.lineTo(x + width - topRight, y); + ctx.quadraticCurveTo(x + width, y, x + width, y + topRight); + if (yAlign === 'center' && xAlign === 'right') { + this.drawCaret(pt, ctx, tooltipSize, options); + } + ctx.lineTo(x + width, y + height - bottomRight); + ctx.quadraticCurveTo(x + width, y + height, x + width - bottomRight, y + height); + if (yAlign === 'bottom') { + this.drawCaret(pt, ctx, tooltipSize, options); + } + ctx.lineTo(x + bottomLeft, y + height); + ctx.quadraticCurveTo(x, y + height, x, y + height - bottomLeft); + if (yAlign === 'center' && xAlign === 'left') { + this.drawCaret(pt, ctx, tooltipSize, options); + } + ctx.lineTo(x, y + topLeft); + ctx.quadraticCurveTo(x, y, x + topLeft, y); + ctx.closePath(); + ctx.fill(); + if (options.borderWidth > 0) { + ctx.stroke(); + } + } + _updateAnimationTarget(options) { + const chart = this.chart; + const anims = this.$animations; + const animX = anims && anims.x; + const animY = anims && anims.y; + if (animX || animY) { + const position = positioners[options.position].call(this, this._active, this._eventPosition); + if (!position) { + return; } - ctx.lineTo(x, y + radius); - ctx.quadraticCurveTo(x, y, x + radius, y); - ctx.closePath(); - ctx.fill(); - if (options.borderWidth > 0) { - ctx.stroke(); + const size = this._size = getTooltipSize(this, options); + const positionAndSize = Object.assign({}, position, this._size); + const alignment = determineAlignment(chart, options, positionAndSize); + const point = getBackgroundPoint(options, positionAndSize, alignment, chart); + if (animX._to !== point.x || animY._to !== point.y) { + this.xAlign = alignment.xAlign; + this.yAlign = alignment.yAlign; + this.width = size.width; + this.height = size.height; + this.caretX = position.x; + this.caretY = position.y; + this._resolveAnimations().update(this, point); } } - ; - _proto._updateAnimationTarget = function _updateAnimationTarget() { - const me = this; - const chart = me._chart; - const options = me.options; - const anims = me.$animations; - const animX = anims && anims.x; - const animY = anims && anims.y; - if (animX || animY) { - const position = positioners[options.position].call(me, me._active, me._eventPosition); - if (!position) { - return; - } - const size = me._size = getTooltipSize(me); - const positionAndSize = _extends({}, position, me._size); - const alignment = determineAlignment(chart, options, positionAndSize); - const point = getBackgroundPoint(options, positionAndSize, alignment, chart); - if (animX._to !== point.x || animY._to !== point.y) { - me.xAlign = alignment.xAlign; - me.yAlign = alignment.yAlign; - me.width = size.width; - me.height = size.height; - me.caretX = position.x; - me.caretY = position.y; - me._resolveAnimations().update(me, point); - } - } + } + _willRender() { + return !!this.opacity; + } + draw(ctx) { + const options = this.options.setContext(this.getContext()); + let opacity = this.opacity; + if (!opacity) { + return; + } + this._updateAnimationTarget(options); + const tooltipSize = { + width: this.width, + height: this.height }; - _proto.draw = function draw(ctx) { - const me = this; - const options = me.options; - let opacity = me.opacity; - if (!opacity) { - return; + const pt = { + x: this.x, + y: this.y + }; + opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity; + const padding = toPadding(options.padding); + const hasTooltipContent = this.title.length || this.beforeBody.length || this.body.length || this.afterBody.length || this.footer.length; + if (options.enabled && hasTooltipContent) { + ctx.save(); + ctx.globalAlpha = opacity; + this.drawBackground(pt, ctx, tooltipSize, options); + overrideTextDirection(ctx, options.textDirection); + pt.y += padding.top; + this.drawTitle(pt, ctx, options); + this.drawBody(pt, ctx, options); + this.drawFooter(pt, ctx, options); + restoreTextDirection(ctx, options.textDirection); + ctx.restore(); + } + } + getActiveElements() { + return this._active || []; + } + setActiveElements(activeElements, eventPosition) { + const lastActive = this._active; + const active = activeElements.map(({datasetIndex, index}) => { + const meta = this.chart.getDatasetMeta(datasetIndex); + if (!meta) { + throw new Error('Cannot find a dataset at index ' + datasetIndex); } - me._updateAnimationTarget(); - const tooltipSize = { - width: me.width, - height: me.height - }; - const pt = { - x: me.x, - y: me.y + return { + datasetIndex, + element: meta.data[index], + index, }; - opacity = Math.abs(opacity) < 1e-3 ? 0 : opacity; - const hasTooltipContent = me.title.length || me.beforeBody.length || me.body.length || me.afterBody.length || me.footer.length; - if (options.enabled && hasTooltipContent) { - ctx.save(); - ctx.globalAlpha = opacity; - me.drawBackground(pt, ctx, tooltipSize); - overrideTextDirection(ctx, options.textDirection); - pt.y += options.yPadding; - me.drawTitle(pt, ctx); - me.drawBody(pt, ctx); - me.drawFooter(pt, ctx); - restoreTextDirection(ctx, options.textDirection); - ctx.restore(); - } - } - ; - _proto.getActiveElements = function getActiveElements() { - return this._active || []; - } - ; - _proto.setActiveElements = function setActiveElements(activeElements, eventPosition) { - const me = this; - const lastActive = me._active; - const active = activeElements.map(function (_ref) { - const datasetIndex = _ref.datasetIndex, - index = _ref.index; - const meta = me._chart.getDatasetMeta(datasetIndex); - if (!meta) { - throw new Error('Cannot find a dataset at index ' + datasetIndex); - } - return { - datasetIndex: datasetIndex, - element: meta.data[index], - index: index + }); + const changed = !_elementsEqual(lastActive, active); + const positionChanged = this._positionChanged(active, eventPosition); + if (changed || positionChanged) { + this._active = active; + this._eventPosition = eventPosition; + this._ignoreReplayEvents = true; + this.update(true); + } + } + handleEvent(e, replay, inChartArea = true) { + if (replay && this._ignoreReplayEvents) { + return false; + } + this._ignoreReplayEvents = false; + const options = this.options; + const lastActive = this._active || []; + const active = this._getActiveElements(e, lastActive, replay, inChartArea); + const positionChanged = this._positionChanged(active, e); + const changed = replay || !_elementsEqual(active, lastActive) || positionChanged; + if (changed) { + this._active = active; + if (options.enabled || options.external) { + this._eventPosition = { + x: e.x, + y: e.y }; - }); - const changed = !_elementsEqual(lastActive, active); - const positionChanged = me._positionChanged(active, eventPosition); - if (changed || positionChanged) { - me._active = active; - me._eventPosition = eventPosition; - me.update(true); - } - } - ; - _proto.handleEvent = function handleEvent(e, replay) { - const me = this; - const options = me.options; - const lastActive = me._active || []; - let changed = false; - let active = []; - if (e.type !== 'mouseout') { - active = me._chart.getElementsAtEventForMode(e, options.mode, options, replay); - if (options.reverse) { - active.reverse(); - } + this.update(true, replay); } - const positionChanged = me._positionChanged(active, e); - changed = replay || !_elementsEqual(active, lastActive) || positionChanged; - if (changed) { - me._active = active; - if (options.enabled || options.custom) { - me._eventPosition = { - x: e.x, - y: e.y - }; - me.update(true); - } - } - return changed; } - ; - _proto._positionChanged = function _positionChanged(active, e) { - const me = this; - const position = positioners[me.options.position].call(me, active, e); - return me.caretX !== position.x || me.caretY !== position.y; - }; - return Tooltip; - }(Element$1); - Tooltip.positioners = positioners; - const plugin_tooltip = { - id: 'tooltip', - _element: Tooltip, - positioners: positioners, - afterInit: function afterInit(chart) { - const tooltipOpts = chart.options.tooltips; - if (tooltipOpts) { - chart.tooltip = new Tooltip({ - _chart: chart - }); - } - }, - beforeUpdate: function beforeUpdate(chart) { - if (chart.tooltip) { - chart.tooltip.initialize(); - } - }, - reset: function reset(chart) { - if (chart.tooltip) { - chart.tooltip.initialize(); - } - }, - afterDraw: function afterDraw(chart) { - const tooltip = chart.tooltip; + return changed; + } + _getActiveElements(e, lastActive, replay, inChartArea) { + const options = this.options; + if (e.type === 'mouseout') { + return []; + } + if (!inChartArea) { + return lastActive; + } + const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay); + if (options.reverse) { + active.reverse(); + } + return active; + } + _positionChanged(active, e) { + const {caretX, caretY, options} = this; + const position = positioners[options.position].call(this, active, e); + return position !== false && (caretX !== position.x || caretY !== position.y); + } +} +Tooltip.positioners = positioners; +var plugin_tooltip = { + id: 'tooltip', + _element: Tooltip, + positioners, + afterInit(chart, _args, options) { + if (options) { + chart.tooltip = new Tooltip({chart, options}); + } + }, + beforeUpdate(chart, _args, options) { + if (chart.tooltip) { + chart.tooltip.initialize(options); + } + }, + reset(chart, _args, options) { + if (chart.tooltip) { + chart.tooltip.initialize(options); + } + }, + afterDraw(chart) { + const tooltip = chart.tooltip; + if (tooltip && tooltip._willRender()) { const args = { - tooltip: tooltip + tooltip }; - if (chart._plugins.notify(chart, 'beforeTooltipDraw', [args]) === false) { + if (chart.notifyPlugins('beforeTooltipDraw', args) === false) { return; } - if (tooltip) { - tooltip.draw(chart.ctx); - } - chart._plugins.notify(chart, 'afterTooltipDraw', [args]); + tooltip.draw(chart.ctx); + chart.notifyPlugins('afterTooltipDraw', args); + } + }, + afterEvent(chart, args) { + if (chart.tooltip) { + const useFinalPosition = args.replay; + if (chart.tooltip.handleEvent(args.event, useFinalPosition, args.inChartArea)) { + args.changed = true; + } + } + }, + defaults: { + enabled: true, + external: null, + position: 'average', + backgroundColor: 'rgba(0,0,0,0.8)', + titleColor: '#fff', + titleFont: { + weight: 'bold', }, - afterEvent: function afterEvent(chart, e, replay) { - if (chart.tooltip) { - const useFinalPosition = replay; - chart.tooltip.handleEvent(e, useFinalPosition); + titleSpacing: 2, + titleMarginBottom: 6, + titleAlign: 'left', + bodyColor: '#fff', + bodySpacing: 2, + bodyFont: { + }, + bodyAlign: 'left', + footerColor: '#fff', + footerSpacing: 2, + footerMarginTop: 6, + footerFont: { + weight: 'bold', + }, + footerAlign: 'left', + padding: 6, + caretPadding: 2, + caretSize: 5, + cornerRadius: 6, + boxHeight: (ctx, opts) => opts.bodyFont.size, + boxWidth: (ctx, opts) => opts.bodyFont.size, + multiKeyBackground: '#fff', + displayColors: true, + boxPadding: 0, + borderColor: 'rgba(0,0,0,0)', + borderWidth: 0, + animation: { + duration: 400, + easing: 'easeOutQuart', + }, + animations: { + numbers: { + type: 'number', + properties: ['x', 'y', 'width', 'height', 'caretX', 'caretY'], + }, + opacity: { + easing: 'linear', + duration: 200 } }, - defaults: { - enabled: true, - custom: null, - position: 'average', - backgroundColor: 'rgba(0,0,0,0.8)', - titleFont: { - style: 'bold', - color: '#fff' + callbacks: { + beforeTitle: noop, + title(tooltipItems) { + if (tooltipItems.length > 0) { + const item = tooltipItems[0]; + const labels = item.chart.data.labels; + const labelCount = labels ? labels.length : 0; + if (this && this.options && this.options.mode === 'dataset') { + return item.dataset.label || ''; + } else if (item.label) { + return item.label; + } else if (labelCount > 0 && item.dataIndex < labelCount) { + return labels[item.dataIndex]; + } + } + return ''; }, - titleSpacing: 2, - titleMarginBottom: 6, - titleAlign: 'left', - bodySpacing: 2, - bodyFont: { - color: '#fff' + afterTitle: noop, + beforeBody: noop, + beforeLabel: noop, + label(tooltipItem) { + if (this && this.options && this.options.mode === 'dataset') { + return tooltipItem.label + ': ' + tooltipItem.formattedValue || tooltipItem.formattedValue; + } + let label = tooltipItem.dataset.label || ''; + if (label) { + label += ': '; + } + const value = tooltipItem.formattedValue; + if (!isNullOrUndef(value)) { + label += value; + } + return label; }, - bodyAlign: 'left', - footerSpacing: 2, - footerMarginTop: 6, - footerFont: { - color: '#fff', - style: 'bold' + labelColor(tooltipItem) { + const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex); + const options = meta.controller.getStyle(tooltipItem.dataIndex); + return { + borderColor: options.borderColor, + backgroundColor: options.backgroundColor, + borderWidth: options.borderWidth, + borderDash: options.borderDash, + borderDashOffset: options.borderDashOffset, + borderRadius: 0, + }; }, - footerAlign: 'left', - yPadding: 6, - xPadding: 6, - caretPadding: 2, - caretSize: 5, - cornerRadius: 6, - multiKeyBackground: '#fff', - displayColors: true, - borderColor: 'rgba(0,0,0,0)', - borderWidth: 0, - animation: { - duration: 400, - easing: 'easeOutQuart', - numbers: { - type: 'number', - properties: ['x', 'y', 'width', 'height', 'caretX', 'caretY'] - }, - opacity: { - easing: 'linear', - duration: 200 - } + labelTextColor() { + return this.options.bodyColor; }, - callbacks: { - beforeTitle: noop, - title: function title(tooltipItems) { - if (tooltipItems.length > 0) { - const item = tooltipItems[0]; - const labels = item.chart.data.labels; - const labelCount = labels ? labels.length : 0; - if (item.label) { - return item.label; - } else if (labelCount > 0 && item.dataIndex < labelCount) { - return labels[item.dataIndex]; - } - } - return ''; - }, - afterTitle: noop, - beforeBody: noop, - beforeLabel: noop, - label: function label(tooltipItem) { - let label = tooltipItem.dataset.label || ''; - if (label) { - label += ': '; - } - const value = tooltipItem.formattedValue; - if (!isNullOrUndef(value)) { - label += value; - } - return label; - }, - labelColor: function labelColor(tooltipItem) { - const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex); - const options = meta.controller.getStyle(tooltipItem.dataIndex); - return { - borderColor: options.borderColor, - backgroundColor: options.backgroundColor - }; - }, - labelTextColor: function labelTextColor() { - return this.options.bodyFont.color; - }, - labelPointStyle: function labelPointStyle(tooltipItem) { - const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex); - const options = meta.controller.getStyle(tooltipItem.dataIndex); - return { - pointStyle: options.pointStyle, - rotation: options.rotation - }; - }, - afterLabel: noop, - afterBody: noop, - beforeFooter: noop, - footer: noop, - afterFooter: noop - } + labelPointStyle(tooltipItem) { + const meta = tooltipItem.chart.getDatasetMeta(tooltipItem.datasetIndex); + const options = meta.controller.getStyle(tooltipItem.dataIndex); + return { + pointStyle: options.pointStyle, + rotation: options.rotation, + }; + }, + afterLabel: noop, + afterBody: noop, + beforeFooter: noop, + footer: noop, + afterFooter: noop + } + }, + defaultRoutes: { + bodyFont: 'font', + footerFont: 'font', + titleFont: 'font' + }, + descriptors: { + _scriptable: (name) => name !== 'filter' && name !== 'itemSort' && name !== 'external', + _indexable: false, + callbacks: { + _scriptable: false, + _indexable: false, + }, + animation: { + _fallback: false + }, + animations: { + _fallback: 'animation' } - }; + }, + additionalOptionScopes: ['interaction'] +}; - const plugins = /*#__PURE__*/Object.freeze({ - __proto__: null, - Filler: plugin_filler, - Legend: plugin_legend, - Title: plugin_title, - Tooltip: plugin_tooltip - }); +var plugins = /*#__PURE__*/Object.freeze({ +__proto__: null, +Decimation: plugin_decimation, +Filler: index, +Legend: plugin_legend, +SubTitle: plugin_subtitle, +Title: plugin_title, +Tooltip: plugin_tooltip +}); - const CategoryScale = function (_Scale) { - _inheritsLoose(CategoryScale, _Scale); - function CategoryScale(cfg) { - let _this; - _this = _Scale.call(this, cfg) || this; - _this._startValue = undefined; - _this._valueRange = 0; - return _this; - } - const _proto = CategoryScale.prototype; - _proto.parse = function parse(raw, index) { +const addIfString = (labels, raw, index, addedLabels) => { + if (typeof raw === 'string') { + index = labels.push(raw) - 1; + addedLabels.unshift({index, label: raw}); + } else if (isNaN(raw)) { + index = null; + } + return index; +}; +function findOrAddLabel(labels, raw, index, addedLabels) { + const first = labels.indexOf(raw); + if (first === -1) { + return addIfString(labels, raw, index, addedLabels); + } + const last = labels.lastIndexOf(raw); + return first !== last ? index : first; +} +const validIndex = (index, max) => index === null ? null : _limitValue(Math.round(index), 0, max); +class CategoryScale extends Scale { + constructor(cfg) { + super(cfg); + this._startValue = undefined; + this._valueRange = 0; + this._addedLabels = []; + } + init(scaleOptions) { + const added = this._addedLabels; + if (added.length) { const labels = this.getLabels(); - if (labels[index] === raw) { - return index; - } - const first = labels.indexOf(raw); - const last = labels.lastIndexOf(raw); - return first === -1 || first !== last ? index : first; - }; - _proto.determineDataLimits = function determineDataLimits() { - const me = this; - const max = me.getLabels().length - 1; - me.min = Math.max(me._userMin || 0, 0); - me.max = Math.min(me._userMax || max, max); - }; - _proto.buildTicks = function buildTicks() { - const me = this; - const min = me.min; - const max = me.max; - const offset = me.options.offset; - const ticks = []; - let labels = me.getLabels(); - labels = min === 0 && max === labels.length - 1 ? labels : labels.slice(min, max + 1); - me._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1); - me._startValue = me.min - (offset ? 0.5 : 0); - for (let value = min; value <= max; value++) { - ticks.push({ - value: value - }); - } - return ticks; - }; - _proto.getLabelForValue = function getLabelForValue(value) { - const me = this; - const labels = me.getLabels(); - if (value >= 0 && value < labels.length) { - return labels[value]; + for (const {index, label} of added) { + if (labels[index] === label) { + labels.splice(index, 1); + } } - return value; + this._addedLabels = []; } - ; - _proto.configure = function configure() { - const me = this; - _Scale.prototype.configure.call(this); - if (!me.isHorizontal()) { - me._reversePixels = !me._reversePixels; - } + super.init(scaleOptions); + } + parse(raw, index) { + if (isNullOrUndef(raw)) { + return null; } - ; - _proto.getPixelForValue = function getPixelForValue(value) { - const me = this; - if (typeof value !== 'number') { - value = me.parse(value); + const labels = this.getLabels(); + index = isFinite(index) && labels[index] === raw ? index + : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels); + return validIndex(index, labels.length - 1); + } + determineDataLimits() { + const {minDefined, maxDefined} = this.getUserBounds(); + let {min, max} = this.getMinMax(true); + if (this.options.bounds === 'ticks') { + if (!minDefined) { + min = 0; } - return me.getPixelForDecimal((value - me._startValue) / me._valueRange); - } - ; - _proto.getPixelForTick = function getPixelForTick(index) { - const me = this; - const ticks = me.ticks; - if (index < 0 || index > ticks.length - 1) { - return null; + if (!maxDefined) { + max = this.getLabels().length - 1; } - return me.getPixelForValue(ticks[index].value); - }; - _proto.getValueForPixel = function getValueForPixel(pixel) { - const me = this; - const value = Math.round(me._startValue + me.getDecimalForPixel(pixel) * me._valueRange); - return Math.min(Math.max(value, 0), me.ticks.length - 1); - }; - _proto.getBasePixel = function getBasePixel() { - return this.bottom; - }; - return CategoryScale; - }(Scale); - CategoryScale.id = 'category'; - CategoryScale.defaults = { - ticks: { - callback: CategoryScale.prototype.getLabelForValue - } - }; - - function niceNum(range) { - const exponent = Math.floor(log10(range)); - const fraction = range / Math.pow(10, exponent); - let niceFraction; - if (fraction <= 1.0) { - niceFraction = 1; - } else if (fraction <= 2) { - niceFraction = 2; - } else if (fraction <= 5) { - niceFraction = 5; - } else { - niceFraction = 10; } - return niceFraction * Math.pow(10, exponent); + this.min = min; + this.max = max; } - function generateTicks(generationOptions, dataRange) { + buildTicks() { + const min = this.min; + const max = this.max; + const offset = this.options.offset; const ticks = []; - const MIN_SPACING = 1e-14; - const stepSize = generationOptions.stepSize, - min = generationOptions.min, - max = generationOptions.max, - precision = generationOptions.precision; - const unit = stepSize || 1; - const maxNumSpaces = generationOptions.maxTicks - 1; - const rmin = dataRange.min, - rmax = dataRange.max; - let spacing = niceNum((rmax - rmin) / maxNumSpaces / unit) * unit; - let factor, niceMin, niceMax, numSpaces; - if (spacing < MIN_SPACING && isNullOrUndef(min) && isNullOrUndef(max)) { - return [{ - value: rmin - }, { - value: rmax - }]; + let labels = this.getLabels(); + labels = (min === 0 && max === labels.length - 1) ? labels : labels.slice(min, max + 1); + this._valueRange = Math.max(labels.length - (offset ? 0 : 1), 1); + this._startValue = this.min - (offset ? 0.5 : 0); + for (let value = min; value <= max; value++) { + ticks.push({value}); } - numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing); - if (numSpaces > maxNumSpaces) { - spacing = niceNum(numSpaces * spacing / maxNumSpaces / unit) * unit; + return ticks; + } + getLabelForValue(value) { + const labels = this.getLabels(); + if (value >= 0 && value < labels.length) { + return labels[value]; } - if (stepSize || isNullOrUndef(precision)) { - factor = Math.pow(10, _decimalPlaces(spacing)); - } else { - factor = Math.pow(10, precision); - spacing = Math.ceil(spacing * factor) / factor; + return value; + } + configure() { + super.configure(); + if (!this.isHorizontal()) { + this._reversePixels = !this._reversePixels; + } + } + getPixelForValue(value) { + if (typeof value !== 'number') { + value = this.parse(value); + } + return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange); + } + getPixelForTick(index) { + const ticks = this.ticks; + if (index < 0 || index > ticks.length - 1) { + return null; } + return this.getPixelForValue(ticks[index].value); + } + getValueForPixel(pixel) { + return Math.round(this._startValue + this.getDecimalForPixel(pixel) * this._valueRange); + } + getBasePixel() { + return this.bottom; + } +} +CategoryScale.id = 'category'; +CategoryScale.defaults = { + ticks: { + callback: CategoryScale.prototype.getLabelForValue + } +}; + +function generateTicks$1(generationOptions, dataRange) { + const ticks = []; + const MIN_SPACING = 1e-14; + const {bounds, step, min, max, precision, count, maxTicks, maxDigits, includeBounds} = generationOptions; + const unit = step || 1; + const maxSpaces = maxTicks - 1; + const {min: rmin, max: rmax} = dataRange; + const minDefined = !isNullOrUndef(min); + const maxDefined = !isNullOrUndef(max); + const countDefined = !isNullOrUndef(count); + const minSpacing = (rmax - rmin) / (maxDigits + 1); + let spacing = niceNum((rmax - rmin) / maxSpaces / unit) * unit; + let factor, niceMin, niceMax, numSpaces; + if (spacing < MIN_SPACING && !minDefined && !maxDefined) { + return [{value: rmin}, {value: rmax}]; + } + numSpaces = Math.ceil(rmax / spacing) - Math.floor(rmin / spacing); + if (numSpaces > maxSpaces) { + spacing = niceNum(numSpaces * spacing / maxSpaces / unit) * unit; + } + if (!isNullOrUndef(precision)) { + factor = Math.pow(10, precision); + spacing = Math.ceil(spacing * factor) / factor; + } + if (bounds === 'ticks') { niceMin = Math.floor(rmin / spacing) * spacing; niceMax = Math.ceil(rmax / spacing) * spacing; - if (stepSize && !isNullOrUndef(min) && !isNullOrUndef(max)) { - if (almostWhole((max - min) / stepSize, spacing / 1000)) { - niceMin = min; - niceMax = max; - } - } + } else { + niceMin = rmin; + niceMax = rmax; + } + if (minDefined && maxDefined && step && almostWhole((max - min) / step, spacing / 1000)) { + numSpaces = Math.round(Math.min((max - min) / spacing, maxTicks)); + spacing = (max - min) / numSpaces; + niceMin = min; + niceMax = max; + } else if (countDefined) { + niceMin = minDefined ? min : niceMin; + niceMax = maxDefined ? max : niceMax; + numSpaces = count - 1; + spacing = (niceMax - niceMin) / numSpaces; + } else { numSpaces = (niceMax - niceMin) / spacing; if (almostEquals(numSpaces, Math.round(numSpaces), spacing / 1000)) { numSpaces = Math.round(numSpaces); } else { numSpaces = Math.ceil(numSpaces); } - niceMin = Math.round(niceMin * factor) / factor; - niceMax = Math.round(niceMax * factor) / factor; - ticks.push({ - value: isNullOrUndef(min) ? niceMin : min - }); - for (let j = 1; j < numSpaces; ++j) { - ticks.push({ - value: Math.round((niceMin + j * spacing) * factor) / factor - }); - } - ticks.push({ - value: isNullOrUndef(max) ? niceMax : max - }); - return ticks; } - const LinearScaleBase = function (_Scale) { - _inheritsLoose(LinearScaleBase, _Scale); - function LinearScaleBase(cfg) { - let _this; - _this = _Scale.call(this, cfg) || this; - _this.start = undefined; - _this.end = undefined; - _this._startValue = undefined; - _this._endValue = undefined; - _this._valueRange = 0; - return _this; - } - const _proto = LinearScaleBase.prototype; - _proto.parse = function parse(raw, index) { - if (isNullOrUndef(raw)) { - return NaN; - } - if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) { - return NaN; - } - return +raw; - }; - _proto.handleTickRangeOptions = function handleTickRangeOptions() { - const me = this; - const opts = me.options; - if (opts.beginAtZero) { - const minSign = sign(me.min); - const maxSign = sign(me.max); - if (minSign < 0 && maxSign < 0) { - me.max = 0; - } else if (minSign > 0 && maxSign > 0) { - me.min = 0; - } - } - const setMin = opts.min !== undefined || opts.suggestedMin !== undefined; - const setMax = opts.max !== undefined || opts.suggestedMax !== undefined; - if (opts.min !== undefined) { - me.min = opts.min; - } else if (opts.suggestedMin !== undefined) { - if (me.min === null) { - me.min = opts.suggestedMin; - } else { - me.min = Math.min(me.min, opts.suggestedMin); - } - } - if (opts.max !== undefined) { - me.max = opts.max; - } else if (opts.suggestedMax !== undefined) { - if (me.max === null) { - me.max = opts.suggestedMax; - } else { - me.max = Math.max(me.max, opts.suggestedMax); - } + const decimalPlaces = Math.max( + _decimalPlaces(spacing), + _decimalPlaces(niceMin) + ); + factor = Math.pow(10, isNullOrUndef(precision) ? decimalPlaces : precision); + niceMin = Math.round(niceMin * factor) / factor; + niceMax = Math.round(niceMax * factor) / factor; + let j = 0; + if (minDefined) { + if (includeBounds && niceMin !== min) { + ticks.push({value: min}); + if (niceMin < min) { + j++; } - if (setMin !== setMax) { - if (me.min >= me.max) { - if (setMin) { - me.max = me.min + 1; - } else { - me.min = me.max - 1; - } - } - } - if (me.min === me.max) { - me.max++; - if (!opts.beginAtZero) { - me.min--; - } - } - }; - _proto.getTickLimit = function getTickLimit() { - const me = this; - const tickOpts = me.options.ticks; - let maxTicksLimit = tickOpts.maxTicksLimit, - stepSize = tickOpts.stepSize; - let maxTicks; - if (stepSize) { - maxTicks = Math.ceil(me.max / stepSize) - Math.floor(me.min / stepSize) + 1; - } else { - maxTicks = me.computeTickLimit(); - maxTicksLimit = maxTicksLimit || 11; + if (almostEquals(Math.round((niceMin + j * spacing) * factor) / factor, min, relativeLabelSize(min, minSpacing, generationOptions))) { + j++; } - if (maxTicksLimit) { - maxTicks = Math.min(maxTicksLimit, maxTicks); + } else if (niceMin < min) { + j++; + } + } + for (; j < numSpaces; ++j) { + ticks.push({value: Math.round((niceMin + j * spacing) * factor) / factor}); + } + if (maxDefined && includeBounds && niceMax !== max) { + if (ticks.length && almostEquals(ticks[ticks.length - 1].value, max, relativeLabelSize(max, minSpacing, generationOptions))) { + ticks[ticks.length - 1].value = max; + } else { + ticks.push({value: max}); + } + } else if (!maxDefined || niceMax === max) { + ticks.push({value: niceMax}); + } + return ticks; +} +function relativeLabelSize(value, minSpacing, {horizontal, minRotation}) { + const rad = toRadians(minRotation); + const ratio = (horizontal ? Math.sin(rad) : Math.cos(rad)) || 0.001; + const length = 0.75 * minSpacing * ('' + value).length; + return Math.min(minSpacing / ratio, length); +} +class LinearScaleBase extends Scale { + constructor(cfg) { + super(cfg); + this.start = undefined; + this.end = undefined; + this._startValue = undefined; + this._endValue = undefined; + this._valueRange = 0; + } + parse(raw, index) { + if (isNullOrUndef(raw)) { + return null; + } + if ((typeof raw === 'number' || raw instanceof Number) && !isFinite(+raw)) { + return null; + } + return +raw; + } + handleTickRangeOptions() { + const {beginAtZero} = this.options; + const {minDefined, maxDefined} = this.getUserBounds(); + let {min, max} = this; + const setMin = v => (min = minDefined ? min : v); + const setMax = v => (max = maxDefined ? max : v); + if (beginAtZero) { + const minSign = sign(min); + const maxSign = sign(max); + if (minSign < 0 && maxSign < 0) { + setMax(0); + } else if (minSign > 0 && maxSign > 0) { + setMin(0); + } + } + if (min === max) { + let offset = 1; + if (max >= Number.MAX_SAFE_INTEGER || min <= Number.MIN_SAFE_INTEGER) { + offset = Math.abs(max * 0.05); + } + setMax(max + offset); + if (!beginAtZero) { + setMin(min - offset); + } + } + this.min = min; + this.max = max; + } + getTickLimit() { + const tickOpts = this.options.ticks; + let {maxTicksLimit, stepSize} = tickOpts; + let maxTicks; + if (stepSize) { + maxTicks = Math.ceil(this.max / stepSize) - Math.floor(this.min / stepSize) + 1; + if (maxTicks > 1000) { + console.warn(`scales.${this.id}.ticks.stepSize: ${stepSize} would result generating up to ${maxTicks} ticks. Limiting to 1000.`); + maxTicks = 1000; } - return maxTicks; + } else { + maxTicks = this.computeTickLimit(); + maxTicksLimit = maxTicksLimit || 11; } - ; - _proto.computeTickLimit = function computeTickLimit() { - return Number.POSITIVE_INFINITY; - }; - _proto.buildTicks = function buildTicks() { - const me = this; - const opts = me.options; - const tickOpts = opts.ticks; - let maxTicks = me.getTickLimit(); - maxTicks = Math.max(2, maxTicks); - const numericGeneratorOptions = { - maxTicks: maxTicks, - min: opts.min, - max: opts.max, - precision: tickOpts.precision, - stepSize: valueOrDefault(tickOpts.fixedStepSize, tickOpts.stepSize) - }; - const ticks = generateTicks(numericGeneratorOptions, me); - _setMinAndMaxByKey(ticks, me, 'value'); - if (opts.reverse) { - ticks.reverse(); - me.start = me.max; - me.end = me.min; - } else { - me.start = me.min; - me.end = me.max; - } - return ticks; - } - ; - _proto.configure = function configure() { - const me = this; - const ticks = me.ticks; - let start = me.min; - let end = me.max; - _Scale.prototype.configure.call(this); - if (me.options.offset && ticks.length) { - const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2; - start -= offset; - end += offset; - } - me._startValue = start; - me._endValue = end; - me._valueRange = end - start; - }; - _proto.getLabelForValue = function getLabelForValue(value) { - return new Intl.NumberFormat(this.options.locale).format(value); - }; - return LinearScaleBase; - }(Scale); - - const LinearScale = function (_LinearScaleBase) { - _inheritsLoose(LinearScale, _LinearScaleBase); - function LinearScale() { - return _LinearScaleBase.apply(this, arguments) || this; - } - const _proto = LinearScale.prototype; - _proto.determineDataLimits = function determineDataLimits() { - const me = this; - const options = me.options; - const _me$getMinMax = me.getMinMax(true), - min = _me$getMinMax.min, - max = _me$getMinMax.max; - me.min = isNumberFinite(min) ? min : valueOrDefault(options.suggestedMin, 0); - me.max = isNumberFinite(max) ? max : valueOrDefault(options.suggestedMax, 1); - if (options.stacked && min > 0) { - me.min = 0; - } - me.handleTickRangeOptions(); - } - ; - _proto.computeTickLimit = function computeTickLimit() { - const me = this; - if (me.isHorizontal()) { - return Math.ceil(me.width / 40); - } - const tickFont = me._resolveTickFontOptions(0); - return Math.ceil(me.height / tickFont.lineHeight); - } - ; - _proto.getPixelForValue = function getPixelForValue(value) { - const me = this; - return me.getPixelForDecimal((value - me._startValue) / me._valueRange); - }; - _proto.getValueForPixel = function getValueForPixel(pixel) { - return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange; - }; - return LinearScale; - }(LinearScaleBase); - LinearScale.id = 'linear'; - LinearScale.defaults = { - ticks: { - callback: Ticks.formatters.numeric + if (maxTicksLimit) { + maxTicks = Math.min(maxTicksLimit, maxTicks); } - }; - - function isMajor(tickVal) { - const remain = tickVal / Math.pow(10, Math.floor(log10(tickVal))); - return remain === 1; + return maxTicks; } - function finiteOrDefault(value, def) { - return isNumberFinite(value) ? value : def; + computeTickLimit() { + return Number.POSITIVE_INFINITY; } - function generateTicks$1(generationOptions, dataRange) { - const endExp = Math.floor(log10(dataRange.max)); - const endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp)); - const ticks = []; - let tickVal = finiteOrDefault(generationOptions.min, Math.pow(10, Math.floor(log10(dataRange.min)))); - let exp = Math.floor(log10(tickVal)); - let significand = Math.floor(tickVal / Math.pow(10, exp)); - let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1; - do { - ticks.push({ - value: tickVal, - major: isMajor(tickVal) - }); - ++significand; - if (significand === 10) { - significand = 1; - ++exp; - precision = exp >= 0 ? 1 : precision; - } - tickVal = Math.round(significand * Math.pow(10, exp) * precision) / precision; - } while (exp < endExp || exp === endExp && significand < endSignificand); - const lastTick = finiteOrDefault(generationOptions.max, tickVal); - ticks.push({ - value: lastTick, - major: isMajor(tickVal) - }); + buildTicks() { + const opts = this.options; + const tickOpts = opts.ticks; + let maxTicks = this.getTickLimit(); + maxTicks = Math.max(2, maxTicks); + const numericGeneratorOptions = { + maxTicks, + bounds: opts.bounds, + min: opts.min, + max: opts.max, + precision: tickOpts.precision, + step: tickOpts.stepSize, + count: tickOpts.count, + maxDigits: this._maxDigits(), + horizontal: this.isHorizontal(), + minRotation: tickOpts.minRotation || 0, + includeBounds: tickOpts.includeBounds !== false + }; + const dataRange = this._range || this; + const ticks = generateTicks$1(numericGeneratorOptions, dataRange); + if (opts.bounds === 'ticks') { + _setMinAndMaxByKey(ticks, this, 'value'); + } + if (opts.reverse) { + ticks.reverse(); + this.start = this.max; + this.end = this.min; + } else { + this.start = this.min; + this.end = this.max; + } return ticks; } - const LogarithmicScale = function (_Scale) { - _inheritsLoose(LogarithmicScale, _Scale); - function LogarithmicScale(cfg) { - let _this; - _this = _Scale.call(this, cfg) || this; - _this.start = undefined; - _this.end = undefined; - _this._startValue = undefined; - _this._valueRange = 0; - return _this; - } - const _proto = LogarithmicScale.prototype; - _proto.parse = function parse(raw, index) { - const value = LinearScaleBase.prototype.parse.apply(this, [raw, index]); - if (value === 0) { - this._zero = true; - return undefined; - } - return isNumberFinite(value) && value > 0 ? value : NaN; - }; - _proto.determineDataLimits = function determineDataLimits() { - const me = this; - const _me$getMinMax = me.getMinMax(true), - min = _me$getMinMax.min, - max = _me$getMinMax.max; - me.min = isNumberFinite(min) ? Math.max(0, min) : null; - me.max = isNumberFinite(max) ? Math.max(0, max) : null; - if (me.options.beginAtZero) { - me._zero = true; - } - me.handleTickRangeOptions(); - }; - _proto.handleTickRangeOptions = function handleTickRangeOptions() { - const me = this; - const _me$options = me.options, - suggestedMax = _me$options.suggestedMax, - suggestedMin = _me$options.suggestedMin; - const DEFAULT_MIN = 1; - const DEFAULT_MAX = 10; - let min = me.min; - let max = me.max; - if (!isNullOrUndef(suggestedMin)) { - min = Math.min(min, suggestedMin); - } - if (!isNullOrUndef(suggestedMax)) { - max = Math.max(max, suggestedMax); - } - if (min === max) { - if (min <= 0) { - min = DEFAULT_MIN; - max = DEFAULT_MAX; - } else { - min = Math.pow(10, Math.floor(log10(min)) - 1); - max = Math.pow(10, Math.floor(log10(max)) + 1); - } - } + configure() { + const ticks = this.ticks; + let start = this.min; + let end = this.max; + super.configure(); + if (this.options.offset && ticks.length) { + const offset = (end - start) / Math.max(ticks.length - 1, 1) / 2; + start -= offset; + end += offset; + } + this._startValue = start; + this._endValue = end; + this._valueRange = end - start; + } + getLabelForValue(value) { + return formatNumber(value, this.chart.options.locale, this.options.ticks.format); + } +} + +class LinearScale extends LinearScaleBase { + determineDataLimits() { + const {min, max} = this.getMinMax(true); + this.min = isNumberFinite(min) ? min : 0; + this.max = isNumberFinite(max) ? max : 1; + this.handleTickRangeOptions(); + } + computeTickLimit() { + const horizontal = this.isHorizontal(); + const length = horizontal ? this.width : this.height; + const minRotation = toRadians(this.options.ticks.minRotation); + const ratio = (horizontal ? Math.sin(minRotation) : Math.cos(minRotation)) || 0.001; + const tickFont = this._resolveTickFontOptions(0); + return Math.ceil(length / Math.min(40, tickFont.lineHeight / ratio)); + } + getPixelForValue(value) { + return value === null ? NaN : this.getPixelForDecimal((value - this._startValue) / this._valueRange); + } + getValueForPixel(pixel) { + return this._startValue + this.getDecimalForPixel(pixel) * this._valueRange; + } +} +LinearScale.id = 'linear'; +LinearScale.defaults = { + ticks: { + callback: Ticks.formatters.numeric + } +}; + +function isMajor(tickVal) { + const remain = tickVal / (Math.pow(10, Math.floor(log10(tickVal)))); + return remain === 1; +} +function generateTicks(generationOptions, dataRange) { + const endExp = Math.floor(log10(dataRange.max)); + const endSignificand = Math.ceil(dataRange.max / Math.pow(10, endExp)); + const ticks = []; + let tickVal = finiteOrDefault(generationOptions.min, Math.pow(10, Math.floor(log10(dataRange.min)))); + let exp = Math.floor(log10(tickVal)); + let significand = Math.floor(tickVal / Math.pow(10, exp)); + let precision = exp < 0 ? Math.pow(10, Math.abs(exp)) : 1; + do { + ticks.push({value: tickVal, major: isMajor(tickVal)}); + ++significand; + if (significand === 10) { + significand = 1; + ++exp; + precision = exp >= 0 ? 1 : precision; + } + tickVal = Math.round(significand * Math.pow(10, exp) * precision) / precision; + } while (exp < endExp || (exp === endExp && significand < endSignificand)); + const lastTick = finiteOrDefault(generationOptions.max, tickVal); + ticks.push({value: lastTick, major: isMajor(tickVal)}); + return ticks; +} +class LogarithmicScale extends Scale { + constructor(cfg) { + super(cfg); + this.start = undefined; + this.end = undefined; + this._startValue = undefined; + this._valueRange = 0; + } + parse(raw, index) { + const value = LinearScaleBase.prototype.parse.apply(this, [raw, index]); + if (value === 0) { + this._zero = true; + return undefined; + } + return isNumberFinite(value) && value > 0 ? value : null; + } + determineDataLimits() { + const {min, max} = this.getMinMax(true); + this.min = isNumberFinite(min) ? Math.max(0, min) : null; + this.max = isNumberFinite(max) ? Math.max(0, max) : null; + if (this.options.beginAtZero) { + this._zero = true; + } + this.handleTickRangeOptions(); + } + handleTickRangeOptions() { + const {minDefined, maxDefined} = this.getUserBounds(); + let min = this.min; + let max = this.max; + const setMin = v => (min = minDefined ? min : v); + const setMax = v => (max = maxDefined ? max : v); + const exp = (v, m) => Math.pow(10, Math.floor(log10(v)) + m); + if (min === max) { if (min <= 0) { - min = Math.pow(10, Math.floor(log10(max)) - 1); - } - if (max <= 0) { - max = Math.pow(10, Math.floor(log10(min)) + 1); - } - if (!me._userMin && me._zero && min === Math.pow(10, Math.floor(log10(me.min)))) { - min = Math.pow(10, Math.floor(log10(min)) - 1); - } - me.min = min; - me.max = max; - }; - _proto.buildTicks = function buildTicks() { - const me = this; - const opts = me.options; - const generationOptions = { - min: me._userMin, - max: me._userMax - }; - const ticks = generateTicks$1(generationOptions, me); - let reverse = !me.isHorizontal(); - _setMinAndMaxByKey(ticks, me, 'value'); - if (opts.reverse) { - reverse = !reverse; - me.start = me.max; - me.end = me.min; + setMin(1); + setMax(10); } else { - me.start = me.min; - me.end = me.max; - } - if (reverse) { - ticks.reverse(); + setMin(exp(min, -1)); + setMax(exp(max, +1)); } - return ticks; } - ; - _proto.getLabelForValue = function getLabelForValue(value) { - return value === undefined ? '0' : new Intl.NumberFormat(this.options.locale).format(value); + if (min <= 0) { + setMin(exp(max, -1)); } - ; - _proto.configure = function configure() { - const me = this; - const start = me.min; - _Scale.prototype.configure.call(this); - me._startValue = log10(start); - me._valueRange = log10(me.max) - log10(start); - }; - _proto.getPixelForValue = function getPixelForValue(value) { - const me = this; - if (value === undefined || value === 0) { - value = me.min; - } - return me.getPixelForDecimal(value === me.min ? 0 : (log10(value) - me._startValue) / me._valueRange); - }; - _proto.getValueForPixel = function getValueForPixel(pixel) { - const me = this; - const decimal = me.getDecimalForPixel(pixel); - return Math.pow(10, me._startValue + decimal * me._valueRange); + if (max <= 0) { + setMax(exp(min, +1)); + } + if (this._zero && this.min !== this._suggestedMin && min === exp(this.min, 0)) { + setMin(exp(min, -1)); + } + this.min = min; + this.max = max; + } + buildTicks() { + const opts = this.options; + const generationOptions = { + min: this._userMin, + max: this._userMax }; - return LogarithmicScale; - }(Scale); - LogarithmicScale.id = 'logarithmic'; - LogarithmicScale.defaults = { - ticks: { - callback: Ticks.formatters.logarithmic, - major: { - enabled: true - } + const ticks = generateTicks(generationOptions, this); + if (opts.bounds === 'ticks') { + _setMinAndMaxByKey(ticks, this, 'value'); } - }; - - function getTickBackdropHeight(opts) { - const tickOpts = opts.ticks; - if (tickOpts.display && opts.display) { - return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + tickOpts.backdropPaddingY * 2; + if (opts.reverse) { + ticks.reverse(); + this.start = this.max; + this.end = this.min; + } else { + this.start = this.min; + this.end = this.max; } - return 0; + return ticks; } - function measureLabelSize(ctx, lineHeight, label) { - if (isArray(label)) { - return { - w: _longestText(ctx, ctx.font, label), - h: label.length * lineHeight - }; + getLabelForValue(value) { + return value === undefined + ? '0' + : formatNumber(value, this.chart.options.locale, this.options.ticks.format); + } + configure() { + const start = this.min; + super.configure(); + this._startValue = log10(start); + this._valueRange = log10(this.max) - log10(start); + } + getPixelForValue(value) { + if (value === undefined || value === 0) { + value = this.min; } - return { - w: ctx.measureText(label).width, - h: lineHeight - }; + if (value === null || isNaN(value)) { + return NaN; + } + return this.getPixelForDecimal(value === this.min + ? 0 + : (log10(value) - this._startValue) / this._valueRange); } - function determineLimits(angle, pos, size, min, max) { - if (angle === min || angle === max) { - return { - start: pos - size / 2, - end: pos + size / 2 - }; - } else if (angle < min || angle > max) { - return { - start: pos - size, - end: pos - }; + getValueForPixel(pixel) { + const decimal = this.getDecimalForPixel(pixel); + return Math.pow(10, this._startValue + decimal * this._valueRange); + } +} +LogarithmicScale.id = 'logarithmic'; +LogarithmicScale.defaults = { + ticks: { + callback: Ticks.formatters.logarithmic, + major: { + enabled: true } + } +}; + +function getTickBackdropHeight(opts) { + const tickOpts = opts.ticks; + if (tickOpts.display && opts.display) { + const padding = toPadding(tickOpts.backdropPadding); + return valueOrDefault(tickOpts.font && tickOpts.font.size, defaults.font.size) + padding.height; + } + return 0; +} +function measureLabelSize(ctx, font, label) { + label = isArray(label) ? label : [label]; + return { + w: _longestText(ctx, font.string, label), + h: label.length * font.lineHeight + }; +} +function determineLimits(angle, pos, size, min, max) { + if (angle === min || angle === max) { return { - start: pos, - end: pos + size + start: pos - (size / 2), + end: pos + (size / 2) }; - } - function fitWithPointLabels(scale) { - const furthestLimits = { - l: 0, - r: scale.width, - t: 0, - b: scale.height - scale.paddingTop + } else if (angle < min || angle > max) { + return { + start: pos - size, + end: pos }; - const furthestAngles = {}; - let i, textSize, pointPosition; - scale._pointLabelSizes = []; - const valueCount = scale.chart.data.labels.length; - for (i = 0; i < valueCount; i++) { - pointPosition = scale.getPointPosition(i, scale.drawingArea + 5); - const context = scale.getContext(i); - const plFont = toFont(resolve([scale.options.pointLabels.font], context, i), scale.chart.options.font); - scale.ctx.font = plFont.string; - textSize = measureLabelSize(scale.ctx, plFont.lineHeight, scale.pointLabels[i]); - scale._pointLabelSizes[i] = textSize; - const angleRadians = scale.getIndexAngle(i); - const angle = toDegrees(angleRadians); - const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180); - const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270); - if (hLimits.start < furthestLimits.l) { - furthestLimits.l = hLimits.start; - furthestAngles.l = angleRadians; - } - if (hLimits.end > furthestLimits.r) { - furthestLimits.r = hLimits.end; - furthestAngles.r = angleRadians; - } - if (vLimits.start < furthestLimits.t) { - furthestLimits.t = vLimits.start; - furthestAngles.t = angleRadians; - } - if (vLimits.end > furthestLimits.b) { - furthestLimits.b = vLimits.end; - furthestAngles.b = angleRadians; - } - } - scale._setReductions(scale.drawingArea, furthestLimits, furthestAngles); - } - function getTextAlignForAngle(angle) { - if (angle === 0 || angle === 180) { - return 'center'; - } else if (angle < 180) { - return 'left'; - } - return 'right'; - } - function fillText(ctx, text, position, lineHeight) { - let y = position.y + lineHeight / 2; - let i, ilen; - if (isArray(text)) { - for (i = 0, ilen = text.length; i < ilen; ++i) { - ctx.fillText(text[i], position.x, y); - y += lineHeight; + } + return { + start: pos, + end: pos + size + }; +} +function fitWithPointLabels(scale) { + const orig = { + l: scale.left + scale._padding.left, + r: scale.right - scale._padding.right, + t: scale.top + scale._padding.top, + b: scale.bottom - scale._padding.bottom + }; + const limits = Object.assign({}, orig); + const labelSizes = []; + const padding = []; + const valueCount = scale._pointLabels.length; + const pointLabelOpts = scale.options.pointLabels; + const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0; + for (let i = 0; i < valueCount; i++) { + const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i)); + padding[i] = opts.padding; + const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle); + const plFont = toFont(opts.font); + const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]); + labelSizes[i] = textSize; + const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle); + const angle = Math.round(toDegrees(angleRadians)); + const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180); + const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270); + updateLimits(limits, orig, angleRadians, hLimits, vLimits); + } + scale.setCenterPoint( + orig.l - limits.l, + limits.r - orig.r, + orig.t - limits.t, + limits.b - orig.b + ); + scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding); +} +function updateLimits(limits, orig, angle, hLimits, vLimits) { + const sin = Math.abs(Math.sin(angle)); + const cos = Math.abs(Math.cos(angle)); + let x = 0; + let y = 0; + if (hLimits.start < orig.l) { + x = (orig.l - hLimits.start) / sin; + limits.l = Math.min(limits.l, orig.l - x); + } else if (hLimits.end > orig.r) { + x = (hLimits.end - orig.r) / sin; + limits.r = Math.max(limits.r, orig.r + x); + } + if (vLimits.start < orig.t) { + y = (orig.t - vLimits.start) / cos; + limits.t = Math.min(limits.t, orig.t - y); + } else if (vLimits.end > orig.b) { + y = (vLimits.end - orig.b) / cos; + limits.b = Math.max(limits.b, orig.b + y); + } +} +function buildPointLabelItems(scale, labelSizes, padding) { + const items = []; + const valueCount = scale._pointLabels.length; + const opts = scale.options; + const extra = getTickBackdropHeight(opts) / 2; + const outerDistance = scale.drawingArea; + const additionalAngle = opts.pointLabels.centerPointLabels ? PI / valueCount : 0; + for (let i = 0; i < valueCount; i++) { + const pointLabelPosition = scale.getPointPosition(i, outerDistance + extra + padding[i], additionalAngle); + const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI))); + const size = labelSizes[i]; + const y = yForAngle(pointLabelPosition.y, size.h, angle); + const textAlign = getTextAlignForAngle(angle); + const left = leftForTextAlign(pointLabelPosition.x, size.w, textAlign); + items.push({ + x: pointLabelPosition.x, + y, + textAlign, + left, + top: y, + right: left + size.w, + bottom: y + size.h + }); + } + return items; +} +function getTextAlignForAngle(angle) { + if (angle === 0 || angle === 180) { + return 'center'; + } else if (angle < 180) { + return 'left'; + } + return 'right'; +} +function leftForTextAlign(x, w, align) { + if (align === 'right') { + x -= w; + } else if (align === 'center') { + x -= (w / 2); + } + return x; +} +function yForAngle(y, h, angle) { + if (angle === 90 || angle === 270) { + y -= (h / 2); + } else if (angle > 270 || angle < 90) { + y -= h; + } + return y; +} +function drawPointLabels(scale, labelCount) { + const {ctx, options: {pointLabels}} = scale; + for (let i = labelCount - 1; i >= 0; i--) { + const optsAtIndex = pointLabels.setContext(scale.getPointLabelContext(i)); + const plFont = toFont(optsAtIndex.font); + const {x, y, textAlign, left, top, right, bottom} = scale._pointLabelItems[i]; + const {backdropColor} = optsAtIndex; + if (!isNullOrUndef(backdropColor)) { + const borderRadius = toTRBLCorners(optsAtIndex.borderRadius); + const padding = toPadding(optsAtIndex.backdropPadding); + ctx.fillStyle = backdropColor; + const backdropLeft = left - padding.left; + const backdropTop = top - padding.top; + const backdropWidth = right - left + padding.width; + const backdropHeight = bottom - top + padding.height; + if (Object.values(borderRadius).some(v => v !== 0)) { + ctx.beginPath(); + addRoundedRectPath(ctx, { + x: backdropLeft, + y: backdropTop, + w: backdropWidth, + h: backdropHeight, + radius: borderRadius, + }); + ctx.fill(); + } else { + ctx.fillRect(backdropLeft, backdropTop, backdropWidth, backdropHeight); } - } else { - ctx.fillText(text, position.x, y); } + renderText( + ctx, + scale._pointLabels[i], + x, + y + (plFont.lineHeight / 2), + plFont, + { + color: optsAtIndex.color, + textAlign: textAlign, + textBaseline: 'middle' + } + ); } - function adjustPointPositionForLabelHeight(angle, textSize, position) { - if (angle === 90 || angle === 270) { - position.y -= textSize.h / 2; - } else if (angle > 270 || angle < 90) { - position.y -= textSize.h; - } +} +function pathRadiusLine(scale, radius, circular, labelCount) { + const {ctx} = scale; + if (circular) { + ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU); + } else { + let pointPosition = scale.getPointPosition(0, radius); + ctx.moveTo(pointPosition.x, pointPosition.y); + for (let i = 1; i < labelCount; i++) { + pointPosition = scale.getPointPosition(i, radius); + ctx.lineTo(pointPosition.x, pointPosition.y); + } + } +} +function drawRadiusLine(scale, gridLineOpts, radius, labelCount) { + const ctx = scale.ctx; + const circular = gridLineOpts.circular; + const {color, lineWidth} = gridLineOpts; + if ((!circular && !labelCount) || !color || !lineWidth || radius < 0) { + return; + } + ctx.save(); + ctx.strokeStyle = color; + ctx.lineWidth = lineWidth; + ctx.setLineDash(gridLineOpts.borderDash); + ctx.lineDashOffset = gridLineOpts.borderDashOffset; + ctx.beginPath(); + pathRadiusLine(scale, radius, circular, labelCount); + ctx.closePath(); + ctx.stroke(); + ctx.restore(); +} +function createPointLabelContext(parent, index, label) { + return createContext(parent, { + label, + index, + type: 'pointLabel' + }); +} +class RadialLinearScale extends LinearScaleBase { + constructor(cfg) { + super(cfg); + this.xCenter = undefined; + this.yCenter = undefined; + this.drawingArea = undefined; + this._pointLabels = []; + this._pointLabelItems = []; + } + setDimensions() { + const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2); + const w = this.width = this.maxWidth - padding.width; + const h = this.height = this.maxHeight - padding.height; + this.xCenter = Math.floor(this.left + w / 2 + padding.left); + this.yCenter = Math.floor(this.top + h / 2 + padding.top); + this.drawingArea = Math.floor(Math.min(w, h) / 2); + } + determineDataLimits() { + const {min, max} = this.getMinMax(false); + this.min = isNumberFinite(min) && !isNaN(min) ? min : 0; + this.max = isNumberFinite(max) && !isNaN(max) ? max : 0; + this.handleTickRangeOptions(); + } + computeTickLimit() { + return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options)); + } + generateTickLabels(ticks) { + LinearScaleBase.prototype.generateTickLabels.call(this, ticks); + this._pointLabels = this.getLabels() + .map((value, index) => { + const label = callback(this.options.pointLabels.callback, [value, index], this); + return label || label === 0 ? label : ''; + }) + .filter((v, i) => this.chart.getDataVisibility(i)); } - function drawPointLabels(scale) { - const ctx = scale.ctx; - const opts = scale.options; - const pointLabelOpts = opts.pointLabels; - const tickBackdropHeight = getTickBackdropHeight(opts); - const outerDistance = scale.getDistanceFromCenterForValue(opts.ticks.reverse ? scale.min : scale.max); - ctx.save(); - ctx.textBaseline = 'middle'; - for (let i = scale.chart.data.labels.length - 1; i >= 0; i--) { - const extra = i === 0 ? tickBackdropHeight / 2 : 0; - const pointLabelPosition = scale.getPointPosition(i, outerDistance + extra + 5); - const context = scale.getContext(i); - const plFont = toFont(resolve([pointLabelOpts.font], context, i), scale.chart.options.font); - ctx.font = plFont.string; - ctx.fillStyle = plFont.color; - const angle = toDegrees(scale.getIndexAngle(i)); - ctx.textAlign = getTextAlignForAngle(angle); - adjustPointPositionForLabelHeight(angle, scale._pointLabelSizes[i], pointLabelPosition); - fillText(ctx, scale.pointLabels[i], pointLabelPosition, plFont.lineHeight); + fit() { + const opts = this.options; + if (opts.display && opts.pointLabels.display) { + fitWithPointLabels(this); + } else { + this.setCenterPoint(0, 0, 0, 0); } - ctx.restore(); } - function drawRadiusLine(scale, gridLineOpts, radius, index) { - const ctx = scale.ctx; - const circular = gridLineOpts.circular; - const valueCount = scale.chart.data.labels.length; - const context = scale.getContext(index); - const lineColor = resolve([gridLineOpts.color], context, index - 1); - const lineWidth = resolve([gridLineOpts.lineWidth], context, index - 1); - let pointPosition; - if (!circular && !valueCount || !lineColor || !lineWidth) { - return; + setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) { + this.xCenter += Math.floor((leftMovement - rightMovement) / 2); + this.yCenter += Math.floor((topMovement - bottomMovement) / 2); + this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement)); + } + getIndexAngle(index) { + const angleMultiplier = TAU / (this._pointLabels.length || 1); + const startAngle = this.options.startAngle || 0; + return _normalizeAngle(index * angleMultiplier + toRadians(startAngle)); + } + getDistanceFromCenterForValue(value) { + if (isNullOrUndef(value)) { + return NaN; } - ctx.save(); - ctx.strokeStyle = lineColor; - ctx.lineWidth = lineWidth; - if (ctx.setLineDash) { - ctx.setLineDash(resolve([gridLineOpts.borderDash, []], context)); - ctx.lineDashOffset = resolve([gridLineOpts.borderDashOffset], context, index - 1); + const scalingFactor = this.drawingArea / (this.max - this.min); + if (this.options.reverse) { + return (this.max - value) * scalingFactor; } - ctx.beginPath(); - if (circular) { - ctx.arc(scale.xCenter, scale.yCenter, radius, 0, TAU); - } else { - pointPosition = scale.getPointPosition(0, radius); - ctx.moveTo(pointPosition.x, pointPosition.y); - for (let i = 1; i < valueCount; i++) { - pointPosition = scale.getPointPosition(i, radius); - ctx.lineTo(pointPosition.x, pointPosition.y); - } + return (value - this.min) * scalingFactor; + } + getValueForDistanceFromCenter(distance) { + if (isNullOrUndef(distance)) { + return NaN; } - ctx.closePath(); - ctx.stroke(); - ctx.restore(); + const scaledDistance = distance / (this.drawingArea / (this.max - this.min)); + return this.options.reverse ? this.max - scaledDistance : this.min + scaledDistance; } - function numberOrZero$1(param) { - return isNumber(param) ? param : 0; - } - const RadialLinearScale = function (_LinearScaleBase) { - _inheritsLoose(RadialLinearScale, _LinearScaleBase); - function RadialLinearScale(cfg) { - let _this; - _this = _LinearScaleBase.call(this, cfg) || this; - _this.xCenter = undefined; - _this.yCenter = undefined; - _this.drawingArea = undefined; - _this.pointLabels = []; - return _this; - } - const _proto = RadialLinearScale.prototype; - _proto.init = function init(options) { - _LinearScaleBase.prototype.init.call(this, options); - this.axis = 'r'; - }; - _proto.setDimensions = function setDimensions() { - const me = this; - me.width = me.maxWidth; - me.height = me.maxHeight; - me.paddingTop = getTickBackdropHeight(me.options) / 2; - me.xCenter = Math.floor(me.width / 2); - me.yCenter = Math.floor((me.height - me.paddingTop) / 2); - me.drawingArea = Math.min(me.height - me.paddingTop, me.width) / 2; + getPointLabelContext(index) { + const pointLabels = this._pointLabels || []; + if (index >= 0 && index < pointLabels.length) { + const pointLabel = pointLabels[index]; + return createPointLabelContext(this.getContext(), index, pointLabel); + } + } + getPointPosition(index, distanceFromCenter, additionalAngle = 0) { + const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle; + return { + x: Math.cos(angle) * distanceFromCenter + this.xCenter, + y: Math.sin(angle) * distanceFromCenter + this.yCenter, + angle }; - _proto.determineDataLimits = function determineDataLimits() { - const me = this; - const _me$getMinMax = me.getMinMax(false), - min = _me$getMinMax.min, - max = _me$getMinMax.max; - me.min = isNumberFinite(min) && !isNaN(min) ? min : 0; - me.max = isNumberFinite(max) && !isNaN(max) ? max : 0; - me.handleTickRangeOptions(); - } - ; - _proto.computeTickLimit = function computeTickLimit() { - return Math.ceil(this.drawingArea / getTickBackdropHeight(this.options)); + } + getPointPositionForValue(index, value) { + return this.getPointPosition(index, this.getDistanceFromCenterForValue(value)); + } + getBasePosition(index) { + return this.getPointPositionForValue(index || 0, this.getBaseValue()); + } + getPointLabelPosition(index) { + const {left, top, right, bottom} = this._pointLabelItems[index]; + return { + left, + top, + right, + bottom, }; - _proto.generateTickLabels = function generateTickLabels(ticks) { - const me = this; - LinearScaleBase.prototype.generateTickLabels.call(me, ticks); - me.pointLabels = me.chart.data.labels.map(function (value, index) { - const label = callback(me.options.pointLabels.callback, [value, index], me); - return label || label === 0 ? label : ''; + } + drawBackground() { + const {backgroundColor, grid: {circular}} = this.options; + if (backgroundColor) { + const ctx = this.ctx; + ctx.save(); + ctx.beginPath(); + pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length); + ctx.closePath(); + ctx.fillStyle = backgroundColor; + ctx.fill(); + ctx.restore(); + } + } + drawGrid() { + const ctx = this.ctx; + const opts = this.options; + const {angleLines, grid} = opts; + const labelCount = this._pointLabels.length; + let i, offset, position; + if (opts.pointLabels.display) { + drawPointLabels(this, labelCount); + } + if (grid.display) { + this.ticks.forEach((tick, index) => { + if (index !== 0) { + offset = this.getDistanceFromCenterForValue(tick.value); + const optsAtIndex = grid.setContext(this.getContext(index - 1)); + drawRadiusLine(this, optsAtIndex, offset, labelCount); + } }); - }; - _proto.fit = function fit() { - const me = this; - const opts = me.options; - if (opts.display && opts.pointLabels.display) { - fitWithPointLabels(me); - } else { - me.setCenterPoint(0, 0, 0, 0); - } - } - ; - _proto._setReductions = function _setReductions(largestPossibleRadius, furthestLimits, furthestAngles) { - const me = this; - let radiusReductionLeft = furthestLimits.l / Math.sin(furthestAngles.l); - let radiusReductionRight = Math.max(furthestLimits.r - me.width, 0) / Math.sin(furthestAngles.r); - let radiusReductionTop = -furthestLimits.t / Math.cos(furthestAngles.t); - let radiusReductionBottom = -Math.max(furthestLimits.b - (me.height - me.paddingTop), 0) / Math.cos(furthestAngles.b); - radiusReductionLeft = numberOrZero$1(radiusReductionLeft); - radiusReductionRight = numberOrZero$1(radiusReductionRight); - radiusReductionTop = numberOrZero$1(radiusReductionTop); - radiusReductionBottom = numberOrZero$1(radiusReductionBottom); - me.drawingArea = Math.min(Math.floor(largestPossibleRadius - (radiusReductionLeft + radiusReductionRight) / 2), Math.floor(largestPossibleRadius - (radiusReductionTop + radiusReductionBottom) / 2)); - me.setCenterPoint(radiusReductionLeft, radiusReductionRight, radiusReductionTop, radiusReductionBottom); - }; - _proto.setCenterPoint = function setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) { - const me = this; - const maxRight = me.width - rightMovement - me.drawingArea; - const maxLeft = leftMovement + me.drawingArea; - const maxTop = topMovement + me.drawingArea; - const maxBottom = me.height - me.paddingTop - bottomMovement - me.drawingArea; - me.xCenter = Math.floor((maxLeft + maxRight) / 2 + me.left); - me.yCenter = Math.floor((maxTop + maxBottom) / 2 + me.top + me.paddingTop); - }; - _proto.getIndexAngle = function getIndexAngle(index) { - const chart = this.chart; - const angleMultiplier = TAU / chart.data.labels.length; - const options = chart.options || {}; - const startAngle = options.startAngle || 0; - return _normalizeAngle(index * angleMultiplier + toRadians(startAngle)); - }; - _proto.getDistanceFromCenterForValue = function getDistanceFromCenterForValue(value) { - const me = this; - if (isNullOrUndef(value)) { - return NaN; - } - const scalingFactor = me.drawingArea / (me.max - me.min); - if (me.options.reverse) { - return (me.max - value) * scalingFactor; - } - return (value - me.min) * scalingFactor; - }; - _proto.getValueForDistanceFromCenter = function getValueForDistanceFromCenter(distance) { - if (isNullOrUndef(distance)) { - return NaN; - } - const me = this; - const scaledDistance = distance / (me.drawingArea / (me.max - me.min)); - return me.options.reverse ? me.max - scaledDistance : me.min + scaledDistance; - }; - _proto.getPointPosition = function getPointPosition(index, distanceFromCenter) { - const me = this; - const angle = me.getIndexAngle(index) - HALF_PI; - return { - x: Math.cos(angle) * distanceFromCenter + me.xCenter, - y: Math.sin(angle) * distanceFromCenter + me.yCenter, - angle: angle - }; - }; - _proto.getPointPositionForValue = function getPointPositionForValue(index, value) { - return this.getPointPosition(index, this.getDistanceFromCenterForValue(value)); - }; - _proto.getBasePosition = function getBasePosition(index) { - return this.getPointPositionForValue(index || 0, this.getBaseValue()); - } - ; - _proto.drawGrid = function drawGrid() { - const me = this; - const ctx = me.ctx; - const opts = me.options; - const gridLineOpts = opts.gridLines; - const angleLineOpts = opts.angleLines; - let i, offset, position; - if (opts.pointLabels.display) { - drawPointLabels(me); - } - if (gridLineOpts.display) { - me.ticks.forEach(function (tick, index) { - if (index !== 0) { - offset = me.getDistanceFromCenterForValue(me.ticks[index].value); - drawRadiusLine(me, gridLineOpts, offset, index); - } - }); - } - if (angleLineOpts.display) { - ctx.save(); - for (i = me.chart.data.labels.length - 1; i >= 0; i--) { - const context = me.getContext(i); - const lineWidth = resolve([angleLineOpts.lineWidth, gridLineOpts.lineWidth], context, i); - const color = resolve([angleLineOpts.color, gridLineOpts.color], context, i); - if (!lineWidth || !color) { - continue; - } - ctx.lineWidth = lineWidth; - ctx.strokeStyle = color; - if (ctx.setLineDash) { - ctx.setLineDash(resolve([angleLineOpts.borderDash, gridLineOpts.borderDash, []], context)); - ctx.lineDashOffset = resolve([angleLineOpts.borderDashOffset, gridLineOpts.borderDashOffset, 0.0], context, i); - } - offset = me.getDistanceFromCenterForValue(opts.ticks.reverse ? me.min : me.max); - position = me.getPointPosition(i, offset); - ctx.beginPath(); - ctx.moveTo(me.xCenter, me.yCenter); - ctx.lineTo(position.x, position.y); - ctx.stroke(); + } + if (angleLines.display) { + ctx.save(); + for (i = labelCount - 1; i >= 0; i--) { + const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i)); + const {color, lineWidth} = optsAtIndex; + if (!lineWidth || !color) { + continue; } - ctx.restore(); + ctx.lineWidth = lineWidth; + ctx.strokeStyle = color; + ctx.setLineDash(optsAtIndex.borderDash); + ctx.lineDashOffset = optsAtIndex.borderDashOffset; + offset = this.getDistanceFromCenterForValue(opts.ticks.reverse ? this.min : this.max); + position = this.getPointPosition(i, offset); + ctx.beginPath(); + ctx.moveTo(this.xCenter, this.yCenter); + ctx.lineTo(position.x, position.y); + ctx.stroke(); } + ctx.restore(); + } + } + drawBorder() {} + drawLabels() { + const ctx = this.ctx; + const opts = this.options; + const tickOpts = opts.ticks; + if (!tickOpts.display) { + return; } - ; - _proto.drawLabels = function drawLabels() { - const me = this; - const ctx = me.ctx; - const opts = me.options; - const tickOpts = opts.ticks; - if (!tickOpts.display) { + const startAngle = this.getIndexAngle(0); + let offset, width; + ctx.save(); + ctx.translate(this.xCenter, this.yCenter); + ctx.rotate(startAngle); + ctx.textAlign = 'center'; + ctx.textBaseline = 'middle'; + this.ticks.forEach((tick, index) => { + if (index === 0 && !opts.reverse) { return; } - const startAngle = me.getIndexAngle(0); - let offset, width; - ctx.save(); - ctx.translate(me.xCenter, me.yCenter); - ctx.rotate(startAngle); - ctx.textAlign = 'center'; - ctx.textBaseline = 'middle'; - me.ticks.forEach(function (tick, index) { - if (index === 0 && !opts.reverse) { - return; - } - const context = me.getContext(index); - const tickFont = me._resolveTickFontOptions(index); + const optsAtIndex = tickOpts.setContext(this.getContext(index)); + const tickFont = toFont(optsAtIndex.font); + offset = this.getDistanceFromCenterForValue(this.ticks[index].value); + if (optsAtIndex.showLabelBackdrop) { ctx.font = tickFont.string; - offset = me.getDistanceFromCenterForValue(me.ticks[index].value); - const showLabelBackdrop = resolve([tickOpts.showLabelBackdrop], context, index); - if (showLabelBackdrop) { - width = ctx.measureText(tick.label).width; - ctx.fillStyle = resolve([tickOpts.backdropColor], context, index); - ctx.fillRect(-width / 2 - tickOpts.backdropPaddingX, -offset - tickFont.size / 2 - tickOpts.backdropPaddingY, width + tickOpts.backdropPaddingX * 2, tickFont.size + tickOpts.backdropPaddingY * 2); - } - ctx.fillStyle = tickFont.color; - ctx.fillText(tick.label, 0, -offset); + width = ctx.measureText(tick.label).width; + ctx.fillStyle = optsAtIndex.backdropColor; + const padding = toPadding(optsAtIndex.backdropPadding); + ctx.fillRect( + -width / 2 - padding.left, + -offset - tickFont.size / 2 - padding.top, + width + padding.width, + tickFont.size + padding.height + ); + } + renderText(ctx, tick.label, 0, -offset, tickFont, { + color: optsAtIndex.color, }); - ctx.restore(); - } - ; - _proto.drawTitle = function drawTitle() {}; - return RadialLinearScale; - }(LinearScaleBase); - RadialLinearScale.id = 'radialLinear'; - RadialLinearScale.defaults = { + }); + ctx.restore(); + } + drawTitle() {} +} +RadialLinearScale.id = 'radialLinear'; +RadialLinearScale.defaults = { + display: true, + animate: true, + position: 'chartArea', + angleLines: { display: true, - animate: true, - position: 'chartArea', - angleLines: { - display: true, - color: 'rgba(0,0,0,0.1)', - lineWidth: 1, - borderDash: [], - borderDashOffset: 0.0 - }, - gridLines: { - circular: false + lineWidth: 1, + borderDash: [], + borderDashOffset: 0.0 + }, + grid: { + circular: false + }, + startAngle: 0, + ticks: { + showLabelBackdrop: true, + callback: Ticks.formatters.numeric + }, + pointLabels: { + backdropColor: undefined, + backdropPadding: 2, + display: true, + font: { + size: 10 }, - ticks: { - showLabelBackdrop: true, - backdropColor: 'rgba(255,255,255,0.75)', - backdropPaddingY: 2, - backdropPaddingX: 2, - callback: Ticks.formatters.numeric + callback(label) { + return label; }, - pointLabels: { - display: true, - font: { - size: 10 - }, - callback: function callback(label) { - return label; - } - } - }; + padding: 5, + centerPointLabels: false + } +}; +RadialLinearScale.defaultRoutes = { + 'angleLines.color': 'borderColor', + 'pointLabels.color': 'color', + 'ticks.color': 'color' +}; +RadialLinearScale.descriptors = { + angleLines: { + _fallback: 'grid' + } +}; - const MAX_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991; - const INTERVALS = { - millisecond: { - common: true, - size: 1, - steps: 1000 - }, - second: { - common: true, - size: 1000, - steps: 60 - }, - minute: { - common: true, - size: 60000, - steps: 60 - }, - hour: { - common: true, - size: 3600000, - steps: 24 - }, - day: { - common: true, - size: 86400000, - steps: 30 - }, - week: { - common: false, - size: 604800000, - steps: 4 - }, - month: { - common: true, - size: 2.628e9, - steps: 12 - }, - quarter: { - common: false, - size: 7.884e9, - steps: 4 - }, - year: { - common: true, - size: 3.154e10 - } - }; - const UNITS = - Object.keys(INTERVALS); - function sorter(a, b) { - return a - b; +const INTERVALS = { + millisecond: {common: true, size: 1, steps: 1000}, + second: {common: true, size: 1000, steps: 60}, + minute: {common: true, size: 60000, steps: 60}, + hour: {common: true, size: 3600000, steps: 24}, + day: {common: true, size: 86400000, steps: 30}, + week: {common: false, size: 604800000, steps: 4}, + month: {common: true, size: 2.628e9, steps: 12}, + quarter: {common: false, size: 7.884e9, steps: 4}, + year: {common: true, size: 3.154e10} +}; +const UNITS = (Object.keys(INTERVALS)); +function sorter(a, b) { + return a - b; +} +function parse(scale, input) { + if (isNullOrUndef(input)) { + return null; } - function _parse(scale, input) { - if (isNullOrUndef(input)) { - return null; - } - const adapter = scale._adapter; - const options = scale.options.time; - const parser = options.parser, - round = options.round, - isoWeekday = options.isoWeekday; - let value = input; - if (typeof parser === 'function') { - value = parser(value); - } - if (!isNumberFinite(value)) { - value = typeof parser === 'string' ? adapter.parse(value, parser) : adapter.parse(value); - } - if (value === null) { - return value; - } - if (round) { - value = round === 'week' && (isNumber(isoWeekday) || isoWeekday === true) ? scale._adapter.startOf(value, 'isoWeek', isoWeekday) : scale._adapter.startOf(value, round); - } - return +value; + const adapter = scale._adapter; + const {parser, round, isoWeekday} = scale._parseOpts; + let value = input; + if (typeof parser === 'function') { + value = parser(value); } - function determineUnitForAutoTicks(minUnit, min, max, capacity) { - const ilen = UNITS.length; - for (let i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) { - const interval = INTERVALS[UNITS[i]]; - const factor = interval.steps ? interval.steps : MAX_INTEGER; - if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) { - return UNITS[i]; - } - } - return UNITS[ilen - 1]; + if (!isNumberFinite(value)) { + value = typeof parser === 'string' + ? adapter.parse(value, parser) + : adapter.parse(value); } - function determineUnitForFormatting(scale, numTicks, minUnit, min, max) { - for (let i = UNITS.length - 1; i >= UNITS.indexOf(minUnit); i--) { - const unit = UNITS[i]; - if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) { - return unit; - } - } - return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0]; + if (value === null) { + return null; } - function determineMajorUnit(unit) { - for (let i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) { - if (INTERVALS[UNITS[i]].common) { - return UNITS[i]; - } - } + if (round) { + value = round === 'week' && (isNumber(isoWeekday) || isoWeekday === true) + ? adapter.startOf(value, 'isoWeek', isoWeekday) + : adapter.startOf(value, round); + } + return +value; +} +function determineUnitForAutoTicks(minUnit, min, max, capacity) { + const ilen = UNITS.length; + for (let i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) { + const interval = INTERVALS[UNITS[i]]; + const factor = interval.steps ? interval.steps : Number.MAX_SAFE_INTEGER; + if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) { + return UNITS[i]; + } + } + return UNITS[ilen - 1]; +} +function determineUnitForFormatting(scale, numTicks, minUnit, min, max) { + for (let i = UNITS.length - 1; i >= UNITS.indexOf(minUnit); i--) { + const unit = UNITS[i]; + if (INTERVALS[unit].common && scale._adapter.diff(max, min, unit) >= numTicks - 1) { + return unit; + } + } + return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0]; +} +function determineMajorUnit(unit) { + for (let i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) { + if (INTERVALS[UNITS[i]].common) { + return UNITS[i]; + } + } +} +function addTick(ticks, time, timestamps) { + if (!timestamps) { + ticks[time] = true; + } else if (timestamps.length) { + const {lo, hi} = _lookup(timestamps, time); + const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi]; + ticks[timestamp] = true; + } +} +function setMajorTicks(scale, ticks, map, majorUnit) { + const adapter = scale._adapter; + const first = +adapter.startOf(ticks[0].value, majorUnit); + const last = ticks[ticks.length - 1].value; + let major, index; + for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) { + index = map[major]; + if (index >= 0) { + ticks[index].major = true; + } + } + return ticks; +} +function ticksFromTimestamps(scale, values, majorUnit) { + const ticks = []; + const map = {}; + const ilen = values.length; + let i, value; + for (i = 0; i < ilen; ++i) { + value = values[i]; + map[value] = i; + ticks.push({ + value, + major: false + }); } - function addTick(ticks, time, timestamps) { - if (!timestamps) { - ticks[time] = true; - } else if (timestamps.length) { - const _lookup2 = _lookup(timestamps, time), - lo = _lookup2.lo, - hi = _lookup2.hi; - const timestamp = timestamps[lo] >= time ? timestamps[lo] : timestamps[hi]; - ticks[timestamp] = true; + return (ilen === 0 || !majorUnit) ? ticks : setMajorTicks(scale, ticks, map, majorUnit); +} +class TimeScale extends Scale { + constructor(props) { + super(props); + this._cache = { + data: [], + labels: [], + all: [] + }; + this._unit = 'day'; + this._majorUnit = undefined; + this._offsets = {}; + this._normalized = false; + this._parseOpts = undefined; + } + init(scaleOpts, opts) { + const time = scaleOpts.time || (scaleOpts.time = {}); + const adapter = this._adapter = new _adapters._date(scaleOpts.adapters.date); + adapter.init(opts); + mergeIf(time.displayFormats, adapter.formats()); + this._parseOpts = { + parser: time.parser, + round: time.round, + isoWeekday: time.isoWeekday + }; + super.init(scaleOpts); + this._normalized = opts.normalized; + } + parse(raw, index) { + if (raw === undefined) { + return null; } - } - function setMajorTicks(scale, ticks, map, majorUnit) { - const adapter = scale._adapter; - const first = +adapter.startOf(ticks[0].value, majorUnit); - const last = ticks[ticks.length - 1].value; - let major, index; - for (major = first; major <= last; major = +adapter.add(major, 1, majorUnit)) { - index = map[major]; - if (index >= 0) { - ticks[index].major = true; + return parse(this, raw); + } + beforeLayout() { + super.beforeLayout(); + this._cache = { + data: [], + labels: [], + all: [] + }; + } + determineDataLimits() { + const options = this.options; + const adapter = this._adapter; + const unit = options.time.unit || 'day'; + let {min, max, minDefined, maxDefined} = this.getUserBounds(); + function _applyBounds(bounds) { + if (!minDefined && !isNaN(bounds.min)) { + min = Math.min(min, bounds.min); + } + if (!maxDefined && !isNaN(bounds.max)) { + max = Math.max(max, bounds.max); + } + } + if (!minDefined || !maxDefined) { + _applyBounds(this._getLabelBounds()); + if (options.bounds !== 'ticks' || options.ticks.source !== 'labels') { + _applyBounds(this.getMinMax(false)); + } + } + min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit); + max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1; + this.min = Math.min(min, max - 1); + this.max = Math.max(min + 1, max); + } + _getLabelBounds() { + const arr = this.getLabelTimestamps(); + let min = Number.POSITIVE_INFINITY; + let max = Number.NEGATIVE_INFINITY; + if (arr.length) { + min = arr[0]; + max = arr[arr.length - 1]; + } + return {min, max}; + } + buildTicks() { + const options = this.options; + const timeOpts = options.time; + const tickOpts = options.ticks; + const timestamps = tickOpts.source === 'labels' ? this.getLabelTimestamps() : this._generate(); + if (options.bounds === 'ticks' && timestamps.length) { + this.min = this._userMin || timestamps[0]; + this.max = this._userMax || timestamps[timestamps.length - 1]; + } + const min = this.min; + const max = this.max; + const ticks = _filterBetween(timestamps, min, max); + this._unit = timeOpts.unit || (tickOpts.autoSkip + ? determineUnitForAutoTicks(timeOpts.minUnit, this.min, this.max, this._getLabelCapacity(min)) + : determineUnitForFormatting(this, ticks.length, timeOpts.minUnit, this.min, this.max)); + this._majorUnit = !tickOpts.major.enabled || this._unit === 'year' ? undefined + : determineMajorUnit(this._unit); + this.initOffsets(timestamps); + if (options.reverse) { + ticks.reverse(); + } + return ticksFromTimestamps(this, ticks, this._majorUnit); + } + afterAutoSkip() { + if (this.options.offsetAfterAutoskip) { + this.initOffsets(this.ticks.map(tick => +tick.value)); + } + } + initOffsets(timestamps) { + let start = 0; + let end = 0; + let first, last; + if (this.options.offset && timestamps.length) { + first = this.getDecimalForValue(timestamps[0]); + if (timestamps.length === 1) { + start = 1 - first; + } else { + start = (this.getDecimalForValue(timestamps[1]) - first) / 2; } - } - return ticks; + last = this.getDecimalForValue(timestamps[timestamps.length - 1]); + if (timestamps.length === 1) { + end = last; + } else { + end = (last - this.getDecimalForValue(timestamps[timestamps.length - 2])) / 2; + } + } + const limit = timestamps.length < 3 ? 0.5 : 0.25; + start = _limitValue(start, 0, limit); + end = _limitValue(end, 0, limit); + this._offsets = {start, end, factor: 1 / (start + 1 + end)}; + } + _generate() { + const adapter = this._adapter; + const min = this.min; + const max = this.max; + const options = this.options; + const timeOpts = options.time; + const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, this._getLabelCapacity(min)); + const stepSize = valueOrDefault(timeOpts.stepSize, 1); + const weekday = minor === 'week' ? timeOpts.isoWeekday : false; + const hasWeekday = isNumber(weekday) || weekday === true; + const ticks = {}; + let first = min; + let time, count; + if (hasWeekday) { + first = +adapter.startOf(first, 'isoWeek', weekday); + } + first = +adapter.startOf(first, hasWeekday ? 'day' : minor); + if (adapter.diff(max, min, minor) > 100000 * stepSize) { + throw new Error(min + ' and ' + max + ' are too far apart with stepSize of ' + stepSize + ' ' + minor); + } + const timestamps = options.ticks.source === 'data' && this.getDataTimestamps(); + for (time = first, count = 0; time < max; time = +adapter.add(time, stepSize, minor), count++) { + addTick(ticks, time, timestamps); + } + if (time === max || options.bounds === 'ticks' || count === 1) { + addTick(ticks, time, timestamps); + } + return Object.keys(ticks).sort((a, b) => a - b).map(x => +x); + } + getLabelForValue(value) { + const adapter = this._adapter; + const timeOpts = this.options.time; + if (timeOpts.tooltipFormat) { + return adapter.format(value, timeOpts.tooltipFormat); + } + return adapter.format(value, timeOpts.displayFormats.datetime); + } + _tickFormatFunction(time, index, ticks, format) { + const options = this.options; + const formats = options.time.displayFormats; + const unit = this._unit; + const majorUnit = this._majorUnit; + const minorFormat = unit && formats[unit]; + const majorFormat = majorUnit && formats[majorUnit]; + const tick = ticks[index]; + const major = majorUnit && majorFormat && tick && tick.major; + const label = this._adapter.format(time, format || (major ? majorFormat : minorFormat)); + const formatter = options.ticks.callback; + return formatter ? callback(formatter, [label, index, ticks], this) : label; + } + generateTickLabels(ticks) { + let i, ilen, tick; + for (i = 0, ilen = ticks.length; i < ilen; ++i) { + tick = ticks[i]; + tick.label = this._tickFormatFunction(tick.value, i, ticks); + } + } + getDecimalForValue(value) { + return value === null ? NaN : (value - this.min) / (this.max - this.min); + } + getPixelForValue(value) { + const offsets = this._offsets; + const pos = this.getDecimalForValue(value); + return this.getPixelForDecimal((offsets.start + pos) * offsets.factor); + } + getValueForPixel(pixel) { + const offsets = this._offsets; + const pos = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end; + return this.min + pos * (this.max - this.min); + } + _getLabelSize(label) { + const ticksOpts = this.options.ticks; + const tickLabelWidth = this.ctx.measureText(label).width; + const angle = toRadians(this.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation); + const cosRotation = Math.cos(angle); + const sinRotation = Math.sin(angle); + const tickFontSize = this._resolveTickFontOptions(0).size; + return { + w: (tickLabelWidth * cosRotation) + (tickFontSize * sinRotation), + h: (tickLabelWidth * sinRotation) + (tickFontSize * cosRotation) + }; } - function ticksFromTimestamps(scale, values, majorUnit) { - const ticks = []; - const map = {}; - const ilen = values.length; - let i, value; - for (i = 0; i < ilen; ++i) { - value = values[i]; - map[value] = i; - ticks.push({ - value: value, - major: false - }); - } - return ilen === 0 || !majorUnit ? ticks : setMajorTicks(scale, ticks, map, majorUnit); + _getLabelCapacity(exampleTime) { + const timeOpts = this.options.time; + const displayFormats = timeOpts.displayFormats; + const format = displayFormats[timeOpts.unit] || displayFormats.millisecond; + const exampleLabel = this._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(this, [exampleTime], this._majorUnit), format); + const size = this._getLabelSize(exampleLabel); + const capacity = Math.floor(this.isHorizontal() ? this.width / size.w : this.height / size.h) - 1; + return capacity > 0 ? capacity : 1; } - const TimeScale = function (_Scale) { - _inheritsLoose(TimeScale, _Scale); - function TimeScale(props) { - let _this; - _this = _Scale.call(this, props) || this; - _this._cache = { - data: [], - labels: [], - all: [] - }; - _this._unit = 'day'; - _this._majorUnit = undefined; - _this._offsets = {}; - _this._normalized = false; - return _this; - } - const _proto = TimeScale.prototype; - _proto.init = function init(scaleOpts, opts) { - const time = scaleOpts.time || (scaleOpts.time = {}); - const adapter = this._adapter = new _adapters._date(scaleOpts.adapters.date); - mergeIf(time.displayFormats, adapter.formats()); - _Scale.prototype.init.call(this, scaleOpts); - this._normalized = opts.normalized; - } - ; - _proto.parse = function parse(raw, index) { - if (raw === undefined) { - return NaN; - } - return _parse(this, raw); - }; - _proto.invalidateCaches = function invalidateCaches() { - this._cache = { - data: [], - labels: [], - all: [] - }; - }; - _proto.determineDataLimits = function determineDataLimits() { - const me = this; - const options = me.options; - const adapter = me._adapter; - const unit = options.time.unit || 'day'; - let _me$getUserBounds = me.getUserBounds(), - min = _me$getUserBounds.min, - max = _me$getUserBounds.max, - minDefined = _me$getUserBounds.minDefined, - maxDefined = _me$getUserBounds.maxDefined; - function _applyBounds(bounds) { - if (!minDefined && !isNaN(bounds.min)) { - min = Math.min(min, bounds.min); - } - if (!maxDefined && !isNaN(bounds.max)) { - max = Math.max(max, bounds.max); - } - } - if (!minDefined || !maxDefined) { - _applyBounds(me._getLabelBounds()); - if (options.bounds !== 'ticks' || options.ticks.source !== 'labels') { - _applyBounds(me.getMinMax(false)); - } - } - min = isNumberFinite(min) && !isNaN(min) ? min : +adapter.startOf(Date.now(), unit); - max = isNumberFinite(max) && !isNaN(max) ? max : +adapter.endOf(Date.now(), unit) + 1; - me.min = Math.min(min, max); - me.max = Math.max(min + 1, max); - } - ; - _proto._getLabelBounds = function _getLabelBounds() { - const arr = this.getLabelTimestamps(); - let min = Number.POSITIVE_INFINITY; - let max = Number.NEGATIVE_INFINITY; - if (arr.length) { - min = arr[0]; - max = arr[arr.length - 1]; - } - return { - min: min, - max: max - }; - } - ; - _proto.buildTicks = function buildTicks() { - const me = this; - const options = me.options; - const timeOpts = options.time; - const tickOpts = options.ticks; - const timestamps = tickOpts.source === 'labels' ? me.getLabelTimestamps() : me._generate(); - if (options.bounds === 'ticks' && timestamps.length) { - me.min = me._userMin || timestamps[0]; - me.max = me._userMax || timestamps[timestamps.length - 1]; - } - const min = me.min; - const max = me.max; - const ticks = _filterBetween(timestamps, min, max); - me._unit = timeOpts.unit || (tickOpts.autoSkip ? determineUnitForAutoTicks(timeOpts.minUnit, me.min, me.max, me._getLabelCapacity(min)) : determineUnitForFormatting(me, ticks.length, timeOpts.minUnit, me.min, me.max)); - me._majorUnit = !tickOpts.major.enabled || me._unit === 'year' ? undefined : determineMajorUnit(me._unit); - me.initOffsets(timestamps); - if (options.reverse) { - ticks.reverse(); - } - return ticksFromTimestamps(me, ticks, me._majorUnit); - } - ; - _proto.initOffsets = function initOffsets(timestamps) { - const me = this; - let start = 0; - let end = 0; - let first, last; - if (me.options.offset && timestamps.length) { - first = me.getDecimalForValue(timestamps[0]); - if (timestamps.length === 1) { - start = 1 - first; - } else { - start = (me.getDecimalForValue(timestamps[1]) - first) / 2; - } - last = me.getDecimalForValue(timestamps[timestamps.length - 1]); - if (timestamps.length === 1) { - end = last; - } else { - end = (last - me.getDecimalForValue(timestamps[timestamps.length - 2])) / 2; - } - } - me._offsets = { - start: start, - end: end, - factor: 1 / (start + 1 + end) - }; + getDataTimestamps() { + let timestamps = this._cache.data || []; + let i, ilen; + if (timestamps.length) { + return timestamps; } - ; - _proto._generate = function _generate() { - const me = this; - const adapter = me._adapter; - const min = me.min; - const max = me.max; - const options = me.options; - const timeOpts = options.time; - const minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, me._getLabelCapacity(min)); - const stepSize = valueOrDefault(timeOpts.stepSize, 1); - const weekday = minor === 'week' ? timeOpts.isoWeekday : false; - const hasWeekday = isNumber(weekday) || weekday === true; - const ticks = {}; - let first = min; - let time; - if (hasWeekday) { - first = +adapter.startOf(first, 'isoWeek', weekday); - } - first = +adapter.startOf(first, hasWeekday ? 'day' : minor); - if (adapter.diff(max, min, minor) > 100000 * stepSize) { - throw new Error(min + ' and ' + max + ' are too far apart with stepSize of ' + stepSize + ' ' + minor); - } - const timestamps = options.ticks.source === 'data' && me.getDataTimestamps(); - for (time = first; time < max; time = +adapter.add(time, stepSize, minor)) { - addTick(ticks, time, timestamps); - } - if (time === max || options.bounds === 'ticks') { - addTick(ticks, time, timestamps); - } - return Object.keys(ticks).sort(function (a, b) { - return a - b; - }).map(function (x) { - return +x; - }); + const metas = this.getMatchingVisibleMetas(); + if (this._normalized && metas.length) { + return (this._cache.data = metas[0].controller.getAllParsedValues(this)); } - ; - _proto.getLabelForValue = function getLabelForValue(value) { - const me = this; - const adapter = me._adapter; - const timeOpts = me.options.time; - if (timeOpts.tooltipFormat) { - return adapter.format(value, timeOpts.tooltipFormat); - } - return adapter.format(value, timeOpts.displayFormats.datetime); - } - ; - _proto._tickFormatFunction = function _tickFormatFunction(time, index, ticks, format) { - const me = this; - const options = me.options; - const formats = options.time.displayFormats; - const unit = me._unit; - const majorUnit = me._majorUnit; - const minorFormat = unit && formats[unit]; - const majorFormat = majorUnit && formats[majorUnit]; - const tick = ticks[index]; - const major = majorUnit && majorFormat && tick && tick.major; - const label = me._adapter.format(time, format || (major ? majorFormat : minorFormat)); - const formatter = options.ticks.callback; - return formatter ? formatter(label, index, ticks) : label; - } - ; - _proto.generateTickLabels = function generateTickLabels(ticks) { - let i, ilen, tick; - for (i = 0, ilen = ticks.length; i < ilen; ++i) { - tick = ticks[i]; - tick.label = this._tickFormatFunction(tick.value, i, ticks); - } - } - ; - _proto.getDecimalForValue = function getDecimalForValue(value) { - const me = this; - return (value - me.min) / (me.max - me.min); - } - ; - _proto.getPixelForValue = function getPixelForValue(value) { - const me = this; - const offsets = me._offsets; - const pos = me.getDecimalForValue(value); - return me.getPixelForDecimal((offsets.start + pos) * offsets.factor); - } - ; - _proto.getValueForPixel = function getValueForPixel(pixel) { - const me = this; - const offsets = me._offsets; - const pos = me.getDecimalForPixel(pixel) / offsets.factor - offsets.end; - return me.min + pos * (me.max - me.min); - } - ; - _proto._getLabelSize = function _getLabelSize(label) { - const me = this; - const ticksOpts = me.options.ticks; - const tickLabelWidth = me.ctx.measureText(label).width; - const angle = toRadians(me.isHorizontal() ? ticksOpts.maxRotation : ticksOpts.minRotation); - const cosRotation = Math.cos(angle); - const sinRotation = Math.sin(angle); - const tickFontSize = me._resolveTickFontOptions(0).size; - return { - w: tickLabelWidth * cosRotation + tickFontSize * sinRotation, - h: tickLabelWidth * sinRotation + tickFontSize * cosRotation - }; + for (i = 0, ilen = metas.length; i < ilen; ++i) { + timestamps = timestamps.concat(metas[i].controller.getAllParsedValues(this)); } - ; - _proto._getLabelCapacity = function _getLabelCapacity(exampleTime) { - const me = this; - const timeOpts = me.options.time; - const displayFormats = timeOpts.displayFormats; - const format = displayFormats[timeOpts.unit] || displayFormats.millisecond; - const exampleLabel = me._tickFormatFunction(exampleTime, 0, ticksFromTimestamps(me, [exampleTime], me._majorUnit), format); - const size = me._getLabelSize(exampleLabel); - const capacity = Math.floor(me.isHorizontal() ? me.width / size.w : me.height / size.h) - 1; - return capacity > 0 ? capacity : 1; - } - ; - _proto.getDataTimestamps = function getDataTimestamps() { - const me = this; - let timestamps = me._cache.data || []; - let i, ilen; - if (timestamps.length) { - return timestamps; - } - const metas = me.getMatchingVisibleMetas(); - if (me._normalized && metas.length) { - return me._cache.data = metas[0].controller.getAllParsedValues(me); - } - for (i = 0, ilen = metas.length; i < ilen; ++i) { - timestamps = timestamps.concat(metas[i].controller.getAllParsedValues(me)); - } - return me._cache.data = me.normalize(timestamps); + return (this._cache.data = this.normalize(timestamps)); + } + getLabelTimestamps() { + const timestamps = this._cache.labels || []; + let i, ilen; + if (timestamps.length) { + return timestamps; } - ; - _proto.getLabelTimestamps = function getLabelTimestamps() { - const me = this; - const timestamps = me._cache.labels || []; - let i, ilen; - if (timestamps.length) { - return timestamps; - } - const labels = me.getLabels(); - for (i = 0, ilen = labels.length; i < ilen; ++i) { - timestamps.push(_parse(me, labels[i])); + const labels = this.getLabels(); + for (i = 0, ilen = labels.length; i < ilen; ++i) { + timestamps.push(parse(this, labels[i])); + } + return (this._cache.labels = this._normalized ? timestamps : this.normalize(timestamps)); + } + normalize(values) { + return _arrayUnique(values.sort(sorter)); + } +} +TimeScale.id = 'time'; +TimeScale.defaults = { + bounds: 'data', + adapters: {}, + time: { + parser: false, + unit: false, + round: false, + isoWeekday: false, + minUnit: 'millisecond', + displayFormats: {} + }, + ticks: { + source: 'auto', + major: { + enabled: false + } + } +}; + +function interpolate(table, val, reverse) { + let lo = 0; + let hi = table.length - 1; + let prevSource, nextSource, prevTarget, nextTarget; + if (reverse) { + if (val >= table[lo].pos && val <= table[hi].pos) { + ({lo, hi} = _lookupByKey(table, 'pos', val)); + } + ({pos: prevSource, time: prevTarget} = table[lo]); + ({pos: nextSource, time: nextTarget} = table[hi]); + } else { + if (val >= table[lo].time && val <= table[hi].time) { + ({lo, hi} = _lookupByKey(table, 'time', val)); + } + ({time: prevSource, pos: prevTarget} = table[lo]); + ({time: nextSource, pos: nextTarget} = table[hi]); + } + const span = nextSource - prevSource; + return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget; +} +class TimeSeriesScale extends TimeScale { + constructor(props) { + super(props); + this._table = []; + this._minPos = undefined; + this._tableRange = undefined; + } + initOffsets() { + const timestamps = this._getTimestampsForTable(); + const table = this._table = this.buildLookupTable(timestamps); + this._minPos = interpolate(table, this.min); + this._tableRange = interpolate(table, this.max) - this._minPos; + super.initOffsets(timestamps); + } + buildLookupTable(timestamps) { + const {min, max} = this; + const items = []; + const table = []; + let i, ilen, prev, curr, next; + for (i = 0, ilen = timestamps.length; i < ilen; ++i) { + curr = timestamps[i]; + if (curr >= min && curr <= max) { + items.push(curr); } - return me._cache.labels = me._normalized ? timestamps : me.normalize(timestamps); } - ; - _proto.normalize = function normalize(values) { - return _arrayUnique(values.sort(sorter)); - }; - return TimeScale; - }(Scale); - TimeScale.id = 'time'; - TimeScale.defaults = { - bounds: 'data', - adapters: {}, - time: { - parser: false, - unit: false, - round: false, - isoWeekday: false, - minUnit: 'millisecond', - displayFormats: {} - }, - ticks: { - source: 'auto', - major: { - enabled: false - } + if (items.length < 2) { + return [ + {time: min, pos: 0}, + {time: max, pos: 1} + ]; } - }; - - function interpolate(table, val, reverse) { - let prevSource, nextSource, prevTarget, nextTarget; - if (reverse) { - prevSource = Math.floor(val); - nextSource = Math.ceil(val); - prevTarget = table[prevSource]; - nextTarget = table[nextSource]; - } else { - const result = _lookup(table, val); - prevTarget = result.lo; - nextTarget = result.hi; - prevSource = table[prevTarget]; - nextSource = table[nextTarget]; - } - const span = nextSource - prevSource; - return span ? prevTarget + (nextTarget - prevTarget) * (val - prevSource) / span : prevTarget; - } - const TimeSeriesScale = function (_TimeScale) { - _inheritsLoose(TimeSeriesScale, _TimeScale); - function TimeSeriesScale(props) { - let _this; - _this = _TimeScale.call(this, props) || this; - _this._table = []; - _this._maxIndex = undefined; - return _this; - } - const _proto = TimeSeriesScale.prototype; - _proto.initOffsets = function initOffsets() { - const me = this; - const timestamps = me._getTimestampsForTable(); - me._table = me.buildLookupTable(timestamps); - me._maxIndex = me._table.length - 1; - _TimeScale.prototype.initOffsets.call(this, timestamps); - } - ; - _proto.buildLookupTable = function buildLookupTable(timestamps) { - const me = this; - const min = me.min, - max = me.max; - if (!timestamps.length) { - return [{ - time: min, - pos: 0 - }, { - time: max, - pos: 1 - }]; - } - const items = [min]; - let i, ilen, curr; - for (i = 0, ilen = timestamps.length; i < ilen; ++i) { - curr = timestamps[i]; - if (curr > min && curr < max) { - items.push(curr); - } + for (i = 0, ilen = items.length; i < ilen; ++i) { + next = items[i + 1]; + prev = items[i - 1]; + curr = items[i]; + if (Math.round((next + prev) / 2) !== curr) { + table.push({time: curr, pos: i / (ilen - 1)}); } - items.push(max); - return items; } - ; - _proto._getTimestampsForTable = function _getTimestampsForTable() { - const me = this; - let timestamps = me._cache.all || []; - if (timestamps.length) { - return timestamps; - } - const data = me.getDataTimestamps(); - const label = me.getLabelTimestamps(); - if (data.length && label.length) { - timestamps = me.normalize(data.concat(label)); - } else { - timestamps = data.length ? data : label; - } - timestamps = me._cache.all = timestamps; + return table; + } + _getTimestampsForTable() { + let timestamps = this._cache.all || []; + if (timestamps.length) { return timestamps; } - ; - _proto.getPixelForValue = function getPixelForValue(value, index) { - const me = this; - const offsets = me._offsets; - const pos = me._normalized && me._maxIndex > 0 && !isNullOrUndef(index) ? index / me._maxIndex : me.getDecimalForValue(value); - return me.getPixelForDecimal((offsets.start + pos) * offsets.factor); - } - ; - _proto.getDecimalForValue = function getDecimalForValue(value) { - return interpolate(this._table, value) / this._maxIndex; - } - ; - _proto.getValueForPixel = function getValueForPixel(pixel) { - const me = this; - const offsets = me._offsets; - const decimal = me.getDecimalForPixel(pixel) / offsets.factor - offsets.end; - return interpolate(me._table, decimal * this._maxIndex, true); - }; - return TimeSeriesScale; - }(TimeScale); - TimeSeriesScale.id = 'timeseries'; - TimeSeriesScale.defaults = TimeScale.defaults; - - const scales = /*#__PURE__*/Object.freeze({ - __proto__: null, - CategoryScale: CategoryScale, - LinearScale: LinearScale, - LogarithmicScale: LogarithmicScale, - RadialLinearScale: RadialLinearScale, - TimeScale: TimeScale, - TimeSeriesScale: TimeSeriesScale - }); - - Chart.register(controllers, scales, elements, plugins); - Chart.helpers = _extends({}, helpers); - Chart._adapters = _adapters; - Chart.Animation = Animation; - Chart.Animations = Animations; - Chart.animator = animator; - Chart.controllers = registry.controllers.items; - Chart.DatasetController = DatasetController; - Chart.Element = Element$1; - Chart.elements = elements; - Chart.Interaction = Interaction; - Chart.layouts = layouts; - Chart.platforms = platforms; - Chart.Scale = Scale; - Chart.Ticks = Ticks; - _extends(Chart, controllers, scales, elements, plugins, platforms); - Chart.Chart = Chart; - if (typeof window !== 'undefined') { - window.Chart = Chart; + const data = this.getDataTimestamps(); + const label = this.getLabelTimestamps(); + if (data.length && label.length) { + timestamps = this.normalize(data.concat(label)); + } else { + timestamps = data.length ? data : label; + } + timestamps = this._cache.all = timestamps; + return timestamps; + } + getDecimalForValue(value) { + return (interpolate(this._table, value) - this._minPos) / this._tableRange; } + getValueForPixel(pixel) { + const offsets = this._offsets; + const decimal = this.getDecimalForPixel(pixel) / offsets.factor - offsets.end; + return interpolate(this._table, decimal * this._tableRange + this._minPos, true); + } +} +TimeSeriesScale.id = 'timeseries'; +TimeSeriesScale.defaults = TimeScale.defaults; + +var scales = /*#__PURE__*/Object.freeze({ +__proto__: null, +CategoryScale: CategoryScale, +LinearScale: LinearScale, +LogarithmicScale: LogarithmicScale, +RadialLinearScale: RadialLinearScale, +TimeScale: TimeScale, +TimeSeriesScale: TimeSeriesScale +}); - return Chart; +Chart.register(controllers, scales, elements, plugins); +Chart.helpers = {...helpers}; +Chart._adapters = _adapters; +Chart.Animation = Animation; +Chart.Animations = Animations; +Chart.animator = animator; +Chart.controllers = registry.controllers.items; +Chart.DatasetController = DatasetController; +Chart.Element = Element; +Chart.elements = elements; +Chart.Interaction = Interaction; +Chart.layouts = layouts; +Chart.platforms = platforms; +Chart.Scale = Scale; +Chart.Ticks = Ticks; +Object.assign(Chart, controllers, scales, elements, plugins, platforms); +Chart.Chart = Chart; +if (typeof window !== 'undefined') { + window.Chart = Chart; +} -})(); +return Chart; -export { Chart }; +})); From a7b27cfe615ffa4a166715ce4237e965bf14882e Mon Sep 17 00:00:00 2001 From: a123dat57 Date: Mon, 29 Sep 2025 14:29:47 +0200 Subject: [PATCH 2/4] Update chart.min.js --- www/ftui/modules/chart.js/chart.min.js | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/www/ftui/modules/chart.js/chart.min.js b/www/ftui/modules/chart.js/chart.min.js index 33b48ab1..8f69759e 100755 --- a/www/ftui/modules/chart.js/chart.min.js +++ b/www/ftui/modules/chart.js/chart.min.js @@ -1,7 +1,13 @@ -const Chart=function(){function t(t,e){for(let n=0;n=0||(n[o]=t[o]);return n}function r(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}function a(t,e,n){return e+" "+t+"px "+n}function s(t,e,n){const i=n||function(t){return Array.prototype.slice.call(t)};let o=!1,r=[];return function(){for(var n=arguments.length,a=new Array(n),s=0;s=0;o--)e.call(n,t[o],o);else for(o=0;o=t}function E(t,e,n){let i,o,r;for(i=0,o=t.length;is&&li&&(i=r),i}function Y(t,e,n,i){i=i||{};let o=i.data=i.data||{},r=i.garbageCollect=i.garbageCollect||[];i.font!==e&&(o=i.data={},r=i.garbageCollect=[],i.font=e),t.save(),t.font=e;let a=0;const s=n.length;let l,c,u,f,d;for(l=0;ln.length){for(l=0;l0&&t.stroke()}}function K(t,e){const n=.5;return t.x>e.left-n&&t.xe.top-n&&t.y1;)i=r+o>>1,n(i)?r=i:o=i;return{lo:r,hi:o}}function tt(t,e,n){let i=0,o=t.length;for(;ii&&t[o-1]>n;)o--;return i>0||o0||(Dr.forEach(function(e){delete t[e]}),delete t._chartjs)}function it(t){const e=new Set;let n,i;for(n=0,i=t.length;n0||a>0)s=r,l=a;else{const t=e.getBoundingClientRect();s=o.clientX-t.left,l=o.clientY-t.top,c=!0}return{x:s,y:l,box:c}}function ct(t,e){const n=e.canvas,i=e.currentDevicePixelRatio,o=Ar(n),r="border-box"===o.boxSizing,a=st(o,"padding"),s=st(o,"border","width"),l=lt(t,n),c=l.x,u=l.y,h=l.box,f=a.left+(h&&s.left),d=a.top+(h&&s.top);let p=e.width,g=e.height;return r&&(p-=a.width+s.width,g-=a.height+s.height),{x:Math.round((c-f)/p*n.width/i),y:Math.round((u-d)/g*n.height/i)}}function ut(t,e,n){let i,o;if(void 0===e||void 0===n){const r=ot(t);if(r){const t=r.getBoundingClientRect(),a=Ar(r),s=st(a,"border","width"),l=st(a,"padding");e=t.width-l.width-s.width,n=t.height-l.height-s.height,i=rt(a.maxWidth,r,"clientWidth"),o=rt(a.maxHeight,r,"clientHeight")}else e=t.clientWidth,n=t.clientHeight}return{width:e,height:n,maxWidth:i||xr,maxHeight:o||xr}}function ht(t,e,n,i){const o=Ar(t),r=st(o,"margin"),a=rt(o.maxWidth,t,"clientWidth")||xr,s=rt(o.maxHeight,t,"clientHeight")||xr,l=ut(t,e,n);let c=l.width,u=l.height;if("content-box"===o.boxSizing){const t=st(o,"border","width"),e=st(o,"padding");c-=e.width+t.width,u-=e.height+t.height}return c=Math.max(0,c-r.width),u=Math.max(0,i?Math.floor(c/i):u-r.height),{width:Math.min(c,a,l.maxWidth),height:Math.min(u,s,l.maxHeight)}}function ft(t,e){const n=t.currentDevicePixelRatio=e||"undefined"!=typeof window&&window.devicePixelRatio||1,i=t.canvas,o=t.width,r=t.height;i.height=r*n,i.width=o*n,t.ctx.setTransform(n,0,0,n,0,0),!i.style||i.style.height||i.style.width||(i.style.height=r+"px",i.style.width=o+"px")}function dt(t,e){const n=at(t,e),i=n&&n.match(/^(\d+)(\.\d+)?px$/);return i?+i[1]:void 0}function pt(t,e){return"native"in t?{x:t.x,y:t.y}:ct(t,e)}function gt(t,e){const n=t.getSortedVisibleDatasetMetas();let i,o,r;for(let t=0,a=n.length;t1&&(o=1/(e+n),e*=o,n*=o),o=0;o<3;o++)i[o]*=1-e-n,i[o]+=e;return i}function Ce(t){const e=255,n=t.r/e,i=t.g/e,o=t.b/e,r=Math.max(n,i,o),a=Math.min(n,i,o),s=(r+a)/2;let l,c,u;return r!==a&&(u=r-a,c=s>.5?u/(2-r-a):u/(r+a),l=r===n?(i-o)/u+(i>16&255,r>>8&255,255&r]}return t}function je(t){wa||(wa=He(),wa.transparent=[0,0,0,0]);const e=wa[t.toLowerCase()];return e&&{r:e[0],g:e[1],b:e[2],a:4===e.length?e[3]:255}}function Ye(t,e,n){if(t){let i=Ce(t);i[e]=Math.max(0,Math.min(i[e]+i[e]*n,0===e?360:1)),i=Fe(i),t.r=i[0],t.g=i[1],t.b=i[2]}}function Ue(t,e){return t?n(e||{},t):t}function Xe(t){let 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=Se(t[3]))):(e=Ue(t,{r:0,g:0,b:0,a:1}),e.a=Se(e.a)),e}function $e(t){return"r"===t.charAt(0)?Ae(t):Ve(t)}function Ke(t){return new Ma(t)}function qe(t){return ka(t)?t:Ke(t)}function Ge(t){return ka(t)?t:Ke(t).saturate(.5).darken(.1).hexString()}function Ze(t,e){const i=t.options,o=e.options;i&&o&&(i.$shared&&!o.$shared?t.options=n({},i,o,{$shared:!1}):n(i,o),delete e.options)}function Qe(t){const e={};return Object.keys(t).forEach(function(n){const i=t[n];f(i)||(e[n]=i)}),e}function Je(t,e){const n=[],i=Object.keys(e);for(let e=0;ea+s)))return c}function yn(t,e){g(t,function(t){const n=t.gc,i=n.length/2;let o;if(i>e){for(o=0;oo)return e}return Math.max(o,1)}function kn(t){const e=[];let n,i;for(n=0,i=t.length;n0?e[i-1]:null,a=i0?e[i-1]:null,a=i0&&K(t[n-1],e)&&(o.controlPointPreviousX=Zn(o.controlPointPreviousX,e.left,e.right),o.controlPointPreviousY=Zn(o.controlPointPreviousY,e.top,e.bottom)),n0?e.y:t.y}}function ni(t,e,n,i){const o={x:t.controlPointNextX,y:t.controlPointNextY},r={x:e.controlPointPreviousX,y:e.controlPointPreviousY},a=ti(t,o,n),s=ti(o,r,n),l=ti(r,e,n),c=ti(a,s,n),u=ti(s,l,n);return ti(c,u,n)}function ii(t,e,n){return t?Qa(e,n):Ja()}function oi(t,e){let n,i;"ltr"!==e&&"rtl"!==e||(n=t.canvas.style,i=[n.getPropertyValue("direction"),n.getPropertyPriority("direction")],n.setProperty("direction",e,"important"),t.prevTextDirection=i)}function ri(t,e){void 0!==e&&(delete t.prevTextDirection,t.canvas.style.setProperty("direction",e[0],e[1]))}function ai(t){return"angle"===t?{between:V,compare:I,normalize:B}:{between:function(t,e,n){return t>=e&&t<=n},compare:function(t,e){return t-e},normalize:function(t){return t}}}function si(t,e,n,i){return{start:t%i,end:e%i,loop:n&&(e-t+1)%i==0}}function li(t,e,n){const i=n.property,o=n.start,r=n.end,a=ai(i),s=a.between,l=a.normalize,c=e.length;let u,h,f=t.start,d=t.end,p=t.loop;if(p){for(f+=c,d+=c,u=0,h=c;uo&&t[r%e].skip;)r--;return r%=e,{start:o,end:r}}function fi(t,e,n,i){const o=t.length,r=[];let a,s=e,l=t[e];for(a=e+1;a<=n;++a){const n=t[a%o];n.skip||n.stop?l.skip||(i=!1,r.push({start:e%o,end:(a-1)%o,loop:i}),e=s=n.stop?a:null):(s=a,l.skip&&(e=a)),l=n}return null!==s&&r.push({start:e%o,end:s%o,loop:i}),r}function di(t){const e=t.points,n=t.options.spanGaps,i=e.length;if(!i)return[];const o=!!t._loop,r=hi(e,i,o,n),a=r.start,s=r.end;if(!0===n)return[{start:a,end:s,loop:o}];const l=s0?o[t-1]:null,s=tMath.abs(s)&&(l=s,c=a),e[n.axis]=c,e._custom={barStart:l,barEnd:c,start:o,end:r,min:a,max:s}}function _i(t,e,n,i){return h(t)?yi(t,e,n,i):e[n.axis]=n.parse(t,i),e}function vi(t,e,n,i){const o=t.iScale,r=t.vScale,a=o.getLabels(),s=o===r,l=[];let c,u,h,f;for(c=n,u=n+i;c=gr?-mr:s<-gr?mr:0;const l=s+e,c=Math.cos(s),u=Math.sin(s),h=Math.cos(l),f=Math.sin(l),d=s<=0&&l>=0||l>=mr,p=s<=_r&&l>=_r||l>=mr+_r,g=s===-gr||l>=gr,m=s<=-_r&&l>=-_r||l>=gr+_r,b=g?-1:Math.min(c,c*n,h,h*n),x=m?-1:Math.min(u,u*n,f,f*n),y=d?1:Math.max(c,c*n,h,h*n),_=p?1:Math.max(u,u*n,f,f*n);i=(y-b)/2,o=(_-x)/2,r=-(y+b)/2,a=-(_+x)/2}return{ratioX:i,ratioY:o,offsetX:r,offsetY:a}}function ki(t,e,n){const i=e.length;let o=0,r=i;if(t._sorted){const a=t.iScale,s=t._parsed,l=a.axis,c=a.getUserBounds(),u=c.min,h=c.max,f=c.minDefined,d=c.maxDefined;f&&(o=W(Math.min(Sr(s,a.axis,u).lo,n?i:Sr(e,l,a.getPixelForValue(u)).lo),0,i-1)),r=d?W(Math.max(Sr(s,a.axis,h).hi+1,n?0:Sr(e,l,a.getPixelForValue(h)).hi+1),o,i)-o:i-o}return{start:o,count:r}}function Si(t){const e=t.xScale,i=t.yScale,o=t._scaleRanges,r={xmin:e.min,xmax:e.max,ymin:i.min,ymax:i.max};if(!o)return t._scaleRanges=r,!0;const a=o.xmin!==e.min||o.xmax!==e.max||o.ymin!==i.min||o.ymax!==i.max;return n(o,r),a}function Pi(t){return L(t)-.5*gr}function Di(t,e){const n=e.startAngle,i=e.endAngle,o=e.pixelMargin,r=e.x,a=e.y,s=e.outerRadius,l=e.innerRadius;let c=o/s;t.beginPath(),t.arc(r,a,s,n-c,i+c),l>o?(c=o/l,t.arc(r,a,l,i+c,n-c,!0)):t.arc(r,a,o,i+_r,n-_r),t.closePath(),t.clip()}function Ai(t,e){const n=e.x,i=e.y,o=e.startAngle,r=e.endAngle,a=e.pixelMargin,s=Math.max(e.outerRadius-a,0),l=e.innerRadius+a;t.beginPath(),t.arc(n,i,s,o,r),t.arc(n,i,l,r,o,!0),t.closePath()}function Ti(t,e){if(e.fullCircles){e.endAngle=e.startAngle+mr,Ai(t,e);for(let n=0;nb&&(b=n),y=(_*y+e)/++_):(w(),t.lineTo(e,n),g=i,_=0,m=b=n),x=n}w()}function Bi(t){const e=t.options,n=e.borderDash&&e.borderDash.length,i=!(t._loop||e.tension||e.stepped||n);return i?Ii:zi}function Vi(t){return t.stepped?ei:t.tension?ni:ti}function Wi(t,e){const n=t.getProps(["x","y","base","width","height"],e),i=n.x,o=n.y,r=n.base,a=n.width,s=n.height;let l,c,u,h,f;return t.horizontal?(f=s/2,l=Math.min(i,r),c=Math.max(i,r),u=o-f,h=o+f):(f=a/2,l=i-f,c=i+f,u=Math.min(o,r),h=Math.max(o,r)),{left:l,top:u,right:c,bottom:h}}function Ni(t){let e=t.options.borderSkipped;const n={};return e?(e=t.horizontal?Hi(e,"left","right",t.base>t.x):Hi(e,"bottom","top",t.base=s.left&&e<=s.right)&&(r||n>=s.top&&n<=s.bottom)}function Gi(t){return t.topLeft||t.topRight||t.bottomLeft||t.bottomRight}function Zi(t,e){const n=e.x,i=e.y,o=e.w,r=e.h,a=e.radius;t.arc(n+a.topLeft,i+a.topLeft,a.topLeft,-_r,gr,!0),t.lineTo(n,i+r-a.bottomLeft),t.arc(n+a.bottomLeft,i+r-a.bottomLeft,a.bottomLeft,gr,_r,!0),t.lineTo(n+o-a.bottomRight,i+r),t.arc(n+o-a.bottomRight,i+r-a.bottomRight,a.bottomRight,_r,0,!0),t.lineTo(n+o,i+a.topRight),t.arc(n+o-a.topRight,i+a.topRight,a.topRight,0,-_r,!0),t.lineTo(n+a.topLeft,i)}function Qi(t,e){t.rect(e.x,e.y,e.w,e.h)}function Ji(t,e){const n=t.getDatasetMeta(e),i=n&&t.isDatasetVisible(e);return i?n.dataset:null}function to(t){const e=t.options,n=e.fill;let i=d(n&&n.target,n);return void 0===i&&(i=!!e.backgroundColor),!1!==i&&null!==i&&(!0===i?"origin":i)}function eo(t,e,n){const i=to(t);if(f(i))return!isNaN(i.value)&&i;let o=parseFloat(i);return fr(o)&&Math.floor(o)===o?("-"!==i[0]&&"+"!==i[0]||(o=e+o),!(o===e||o<0||o>=n)&&o):["origin","start","end","stack"].indexOf(i)>=0&&i}function no(t){const e=t.scale,n=void 0===e?{}:e,i=t.fill;let o,r=null;return"start"===i?r=n.bottom:"end"===i?r=n.top:f(i)?r=n.getPixelForValue(i.value):n.getBasePixel&&(r=n.getBasePixel()),fr(r)?(o=n.isHorizontal(),{x:o?r:null,y:o?null:r}):null}function io(t){const e=t.scale,n=t.fill,i=e.options,o=e.getLabels().length,r=[],a=i.reverse?e.max:e.min,s=i.reverse?e.min:e.max;let l,c,u;if(u="start"===n?a:"end"===n?s:f(n)?n.value:e.getBaseValue(),i.gridLines.circular)return c=e.getPointPositionForValue(0,a),new bs({x:c.x,y:c.y,radius:e.getDistanceFromCenterForValue(u)});for(l=0;l=i&&o<=c){s=o===i,l=o===c;break}}return{first:s,last:l,point:i}}function uo(t){const e=t.chart,n=t.fill,i=t.line;if(fr(n))return Ji(e,n);if("stack"===n)return ao(t);const o=oo(t);return o instanceof bs?o:ho(o,i)}function ho(t,e){let n=[],i=!1;return h(t)?(i=!0,n=t):n=ro(t,e),n.length?new ds({points:n,options:{tension:0},_loop:i,_fullLoop:i}):null}function fo(t,e,n){const i=t[e];let o=i.fill;const r=[e];let a;if(!n)return o;for(;!1!==o&&-1===r.indexOf(o);){if(!fr(o))return o;if(a=t[o],!a)return!1;if(a.visible)return o;r.push(o),o=a.fill}return!1}function po(t,e,n){t.beginPath(),e.path(t),t.lineTo(e.last().x,n),t.lineTo(e.first().x,n),t.closePath(),t.clip()}function go(t,e,n,i){if(i)return;let o=e[t],r=n[t];return"angle"===t&&(o=B(o),r=B(r)),{property:t,start:o,end:r}}function mo(t,e,n,i){return t&&e?i(t[n],e[n]):t?t[n]:e?e[n]:0}function bo(t,e,n){const i=t.segments,o=t.points,r=e.points,a=[];for(let t=0;te||u(n)?e:n}function Mo(t,e){const n=t.boxHeight;return t.usePointStyle&&n>e||u(n)?e:n}function ko(t){return!1!==t&&_(Object.create(null),[pr.plugins.legend,t])}function So(t,e){const n=new _s({ctx:t.ctx,options:e,chart:t});Rr.configure(t,n,e),Rr.addBox(t,n),t.legend=n}function Po(t,e){const n=new ws({ctx:t.ctx,options:e,chart:t});Rr.configure(t,n,e),Rr.addBox(t,n),t.titleBlock=n}function Do(t,e){return e&&(h(e)?Array.prototype.push.apply(t,e):t.push(e)),t}function Ao(t){return("string"==typeof t||t instanceof String)&&t.indexOf("\n")>-1?t.split("\n"):t}function To(t,e){const n=e.element,i=e.datasetIndex,o=e.index,r=t.getDatasetMeta(i).controller,a=r.getLabelAndValue(o),s=a.label,l=a.value;return{chart:t,label:s,dataPoint:r.getParsed(o),formattedValue:l,dataset:r.getDataset(),dataIndex:o,datasetIndex:i,element:n}}function Oo(t,e){return t=_(Object.create(null),[pr.plugins.tooltip,t]),t.bodyFont=Pt(t.bodyFont,e),t.titleFont=Pt(t.titleFont,e),t.footerFont=Pt(t.footerFont,e),t.boxHeight=d(t.boxHeight,t.bodyFont.size),t.boxWidth=d(t.boxWidth,t.bodyFont.size),t}function Eo(t){const e=t._chart.ctx,n=t.body,i=t.footer,o=t.options,r=t.title,a=o.bodyFont,s=o.footerFont,l=o.titleFont,c=o.boxWidth,u=o.boxHeight,h=r.length,f=i.length,d=n.length;let p=2*o.yPadding,m=0,b=n.reduce(function(t,e){return t+e.before.length+e.lines.length+e.after.length},0);if(b+=t.beforeBody.length+t.afterBody.length,h&&(p+=h*l.size+(h-1)*o.titleSpacing+o.titleMarginBottom),b){const t=o.displayColors?Math.max(u,a.size):a.size;p+=d*t+(b-d)*a.size+(b-1)*o.bodySpacing}f&&(p+=o.footerMarginTop+f*s.size+(f-1)*o.footerSpacing);let x=0;const y=function(t){m=Math.max(m,e.measureText(t).width+x)};return e.save(),e.font=l.string,g(t.title,y),e.font=a.string,g(t.beforeBody.concat(t.afterBody),y),x=o.displayColors?c+2:0,g(n,function(t){g(t.before,y),g(t.lines,y),g(t.after,y)}),x=0,e.font=s.string,g(t.footer,y),e.restore(),m+=2*o.xPadding,{width:m,height:p}}function Lo(t,e,n){const i=n.x,o=n.y,r=n.width,a=n.height,s=t.chartArea;let l,c,u="center",h="center";ot.height-a/2&&(h="bottom");const f=(s.left+s.right)/2,d=(s.top+s.bottom)/2;"center"===h?(l=function(t){return t<=f},c=function(t){return t>f}):(l=function(t){return t<=r/2},c=function(e){return e>=t.width-r/2});const p=function(n){return n+r+e.caretSize+e.caretPadding>t.width},g=function(t){return t-r-e.caretSize-e.caretPadding<0},m=function(t){return t<=d?"top":"bottom"};return l(i)?(u="left",p(i)&&(u="center",h=m(o))):c(i)&&(u="right",g(i)&&(u="center",h=m(o))),{xAlign:e.xAlign?e.xAlign:u,yAlign:e.yAlign?e.yAlign:h}}function Co(t,e,n){let i=t.x,o=t.width;return"right"===e?i-=o:"center"===e&&(i-=o/2,i+o>n&&(i=n-o),i<0&&(i=0)),i}function Ro(t,e,n){let i=t.y,o=t.height;return"top"===e?i+=n:i-="bottom"===e?o+n:o/2,i}function Fo(t,e,n,i){const o=t.caretSize,r=t.caretPadding,a=t.cornerRadius,s=n.xAlign,l=n.yAlign,c=o+r,u=a+r;let h=Co(e,s,i.width);const f=Ro(e,l,c);return"center"===l?"left"===s?h+=c:"right"===s&&(h-=c):"left"===s?h-=u:"right"===s&&(h+=u),{x:h,y:f}}function zo(t,e){const n=t.options;return"center"===e?t.x+t.width/2:"right"===e?t.x+t.width-n.xPadding:t.x+n.xPadding}function Io(t){return Do([],Ao(t))}function Bo(t){const e=Math.floor(Mr(t)),n=t/Math.pow(10,e);let i;return i=n<=1?1:n<=2?2:n<=5?5:10,i*Math.pow(10,e)}function Vo(t,e){const n=[],i=1e-14,o=t.stepSize,r=t.min,a=t.max,s=t.precision,l=o||1,c=t.maxTicks-1,h=e.min,f=e.max;let d,p,g,m,b=Bo((f-h)/c/l)*l;if(bc&&(b=Bo(m*b/c/l)*l),o||u(s)?d=Math.pow(10,R(b)):(d=Math.pow(10,s),b=Math.ceil(b*d)/d),p=Math.floor(h/b)*b,g=Math.ceil(f/b)*b,!o||u(r)||u(a)||O((a-r)/o,b/1e3)&&(p=r,g=a),m=(g-p)/b,m=T(m,Math.round(m),b/1e3)?Math.round(m):Math.ceil(m),p=Math.round(p*d)/d,g=Math.round(g*d)/d,n.push({value:u(r)?p:r});for(let t=1;t=0?1:l),r=Math.round(s*Math.pow(10,a)*l)/l}while(ao?{start:e-n,end:e}:{start:e,end:e+n}}function Xo(t){const e={l:0,r:t.width,t:0,b:t.height-t.paddingTop},n={};let i,o,r;t._pointLabelSizes=[];const a=t.chart.data.labels.length;for(i=0;ie.r&&(e.r=u.end,n.r=l),h.starte.b&&(e.b=h.end,n.b=l)}t._setReductions(t.drawingArea,e,n)}function $o(t){return 0===t||180===t?"center":t<180?"left":"right"}function Ko(t,e,n,i){let o,r,a=n.y+i/2;if(h(e))for(o=0,r=e.length;o270||t<90)&&(n.y-=e.h)}function Go(t){const e=t.ctx,n=t.options,i=n.pointLabels,o=jo(n),r=t.getDistanceFromCenterForValue(n.ticks.reverse?t.min:t.max);e.save(),e.textBaseline="middle";for(let n=t.chart.data.labels.length-1;n>=0;n--){const a=0===n?o/2:0,s=t.getPointPosition(n,r+a+5),l=t.getContext(n),c=Pt(Dt([i.font],l,n),t.chart.options.font);e.font=c.string,e.fillStyle=c.color;const u=C(t.getIndexAngle(n));e.textAlign=$o(u),qo(u,t._pointLabelSizes[n],s),Ko(e,t.pointLabels[n],s,c.lineHeight)}e.restore()}function Zo(t,e,n,i){const o=t.ctx,r=e.circular,a=t.chart.data.labels.length,s=t.getContext(i),l=Dt([e.color],s,i-1),c=Dt([e.lineWidth],s,i-1);let u;if((r||a)&&l&&c){if(o.save(),o.strokeStyle=l,o.lineWidth=c,o.setLineDash&&(o.setLineDash(Dt([e.borderDash,[]],s)),o.lineDashOffset=Dt([e.borderDashOffset],s,i-1)),o.beginPath(),r)o.arc(t.xCenter,t.yCenter,n,0,mr);else{u=t.getPointPosition(0,n),o.moveTo(u.x,u.y);for(let e=1;e=Fs.indexOf(n);r--){const n=Fs[r];if(Rs[n].common&&t._adapter.diff(o,i,n)>=e-1)return n}return Fs[n?Fs.indexOf(n):0]}function ir(t){for(let e=Fs.indexOf(t)+1,n=Fs.length;e=e?n[o]:n[r];t[a]=!0}}else t[e]=!0}function rr(t,e,n,i){const o=t._adapter,r=+o.startOf(e[0].value,i),a=e[e.length-1].value;let s,l;for(s=r;s<=a;s=+o.add(s,1,i))l=n[s],l>=0&&(e[l].major=!0);return e}function ar(t,e,n){const i=[],o={},r=e.length;let a,s;for(a=0;a=0;--s)a=r[s],a._active?(a.tick(e),c=!0):(r[s]=r[r.length-1],r.pop());c&&(o.draw(),t._notify(o,i,e,"progress")),o.options.animation.debug&&l(o,r.length,e,t._lastDate),r.length||(i.running=!1,t._notify(o,i,e,"complete")),n+=r.length}),t._lastDate=e,0===n&&(t._running=!1)},e._getAnims=function(t){const e=this._charts;let n=e.get(t);return n||(n={running:!1,items:[],listeners:{complete:[],progress:[]}},e.set(t,n)),n},e.listen=function(t,e,n){this._getAnims(t).listeners[e].push(n)},e.add=function(t,e){let n;e&&e.length&&(n=this._getAnims(t).items).push.apply(n,e)},e.has=function(t){return this._getAnims(t).items.length>0},e.start=function(t){const e=this._charts.get(t);e&&(e.running=!0,e.start=Date.now(),e.duration=e.items.reduce(function(t,e){return Math.max(t,e._duration)},0),this._refresh())},e.running=function(t){if(!this._running)return!1;const e=this._charts.get(t);return!!(e&&e.running&&e.items.length)},e.stop=function(t){const e=this._charts.get(t);if(!e||!e.items.length)return;const n=e.items;let i=n.length-1;for(;i>=0;--i)n[i].cancel();e.items=[],this._notify(t,e,Date.now(),"complete")},e.remove=function(t){return this._charts.delete(t)},t}(),ur=new cr,hr=function(){let t=0;return function(){return t++}}(),fr=function(t){return("number"==typeof t||t instanceof Number)&&isFinite(+t)},dr=function(){function t(){this.color="rgba(0,0,0,0.1)",this.elements={},this.events=["mousemove","mouseout","click","touchstart","touchmove"],this.font={color:"#666",family:"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif",size:12,style:"normal",lineHeight:1.2,weight:null,lineWidth:0,strokeStyle:void 0},this.interaction={mode:"nearest",intersect:!0},this.hover={onHover:null},this.maintainAspectRatio=!0,this.onHover=null,this.onClick=null,this.responsive=!0,this.showLine=!0,this.plugins={},this.scale=void 0,this.scales={},this.controllers={}}const e=t.prototype;return e.set=function(t,e){return _(P(this,t),e)},e.get=function(t){return P(this,t)},e.route=function(t,e,n,i){let o;const r=P(this,t),a=P(this,n),s="_"+e;Object.defineProperties(r,(o={},o[s]={writable:!0},o[e]={enumerable:!0,get:function(){return d(this[s],a[i])},set:function(t){this[s]=t}},o))},t}(),pr=new dr,gr=Math.PI,mr=2*gr,br=mr+gr,xr=Number.POSITIVE_INFINITY,yr=gr/180,_r=gr/2,vr=gr/4,wr=2*gr/3,Mr=Math.log10||function(t){const e=Math.log(t)*Math.LOG10E,n=Math.round(e),i=t===Math.pow(10,n);return i?n:e},kr=Math.sign?function(t){return Math.sign(t)}:function(t){return t=+t,0===t||isNaN(t)?t:t>0?1:-1},Sr=function(t,e,n){return J(t,n,function(i){return t[i][e]=n})},Dr=["push","pop","shift","splice","unshift"],Ar=function(t){return window.getComputedStyle(t,null)},Tr=["top","right","bottom","left"],Or=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}(),Er={modes:{index:function(t,e,n,i){const o=pt(e,t),r=n.axis||"x",a=n.intersect?yt(t,o,r,i):_t(t,o,r,!1,i),s=[];return a.length?(t.getSortedVisibleDatasetMetas().forEach(function(t){const e=a[0].index,n=t.data[e];n&&!n.skip&&s.push({element:n,datasetIndex:t.index,index:e})}),s):[]},dataset:function(t,e,n,i){const o=pt(e,t),r=n.axis||"xy";let a=n.intersect?yt(t,o,r,i):_t(t,o,r,!1,i);if(a.length>0){const e=a[0].datasetIndex,n=t.getDatasetMeta(e).data;a=[];for(let t=0;t0},t.prototype.connect_=function(){Br&&!this.connected_&&(document.addEventListener("transitionend",this.onTransitionEnd_),window.addEventListener("resize",this.refresh),Yr?(this.mutationsObserver_=new MutationObserver(this.refresh),this.mutationsObserver_.observe(document,{attributes:!0,childList:!0,characterData:!0,subtree:!0})):(document.addEventListener("DOMSubtreeModified",this.refresh),this.mutationEventsAdded_=!0),this.connected_=!0)},t.prototype.disconnect_=function(){Br&&this.connected_&&(document.removeEventListener("transitionend",this.onTransitionEnd_),window.removeEventListener("resize",this.refresh),this.mutationsObserver_&&this.mutationsObserver_.disconnect(),this.mutationEventsAdded_&&document.removeEventListener("DOMSubtreeModified",this.refresh),this.mutationsObserver_=null,this.mutationEventsAdded_=!1,this.connected_=!1)},t.prototype.onTransitionEnd_=function(t){const e=t.propertyName,n=void 0===e?"":e,i=jr.some(function(t){return!!~n.indexOf(t)});i&&this.refresh()},t.getInstance=function(){return this.instance_||(this.instance_=new t),this.instance_},t.instance_=null,t}(),Xr=function(t,e){for(let n=0,i=Object.keys(e);n0},t}(),Jr="undefined"!=typeof WeakMap?new WeakMap:new Ir,ta=function(){function t(e){if(!(this instanceof t))throw new TypeError("Cannot call a class as a function.");if(!arguments.length)throw new TypeError("1 argument required, but only 0 present.");const n=Ur.getInstance(),i=new Qr(e,n,this);Jr.set(this,i)}return t}();["observe","unobserve","disconnect"].forEach(function(t){ta.prototype[t]=function(){let e;return(e=Jr.get(this))[t].apply(e,arguments)}});const ea=void 0!==Vr.ResizeObserver?Vr.ResizeObserver:ta,na="$chartjs",ia={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"},oa=function(t){return null===t||""===t},ra=!!Or&&{passive:!0},aa=new Map;let sa=0;const la=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);const n=e.prototype;return n.acquireContext=function(t,e){const n=t&&t.getContext&&t.getContext("2d");return n&&n.canvas===t?(Gt(t,e),n):null},n.releaseContext=function(t){const e=t.canvas;if(!e[na])return!1;const n=e[na].initial;["height","width"].forEach(function(t){const i=n[t];u(i)?e.removeAttribute(t):e.setAttribute(t,i)});const i=n.style||{};return Object.keys(i).forEach(function(t){e.style[t]=i[t]}),e.width=e.width,delete e[na],!0},n.addEventListener=function(t,e,n){this.removeEventListener(t,e);const i=t.$proxies||(t.$proxies={}),o={attach:te,detach:ee,resize:re},r=o[e]||se;i[e]=r(t,e,n)},n.removeEventListener=function(t,e){const n=t.$proxies||(t.$proxies={}),i=n[e];if(!i)return;const o={attach:ae,detach:ae,resize:ae},r=o[e]||Qt;r(t,e,i),n[e]=void 0},n.getDevicePixelRatio=function(){return window.devicePixelRatio},n.getMaximumSize=function(t,e,n,i){return ht(t,e,n,i)},n.isAttached=function(t){const e=ot(t);return!(!e||!ot(e))},e}(Fr),ca=Object.freeze({__proto__:null,BasePlatform:Fr,BasicPlatform:zr,DomPlatform:la}),ua=setTimeout;de.prototype.catch=function(t){return this.then(null,t)},de.prototype.then=function(t,e){const n=new this.constructor(he);return pe(this,new xe(t,e,n)),n},de.prototype.finally=le,de.all=function(t){return new de(function(e,n){function i(t,a){try{if(a&&("object"==typeof a||"function"==typeof a)){const e=a.then;if("function"==typeof e)return void e.call(a,function(e){i(t,e)},n)}o[t]=a,0==--r&&e(o)}catch(t){n(t)}}if(!ue(t))return n(new TypeError("Promise.all accepts an array"));const o=Array.prototype.slice.call(t);if(0===o.length)return e([]);let r=o.length;for(let t=0;t=1?t:-(Math.sqrt(1-t*t)-1)},easeOutCirc:function(t){return Math.sqrt(1-(t-=1)*t)},easeInOutCirc:function(t){return(t/=.5)<1?-.5*(Math.sqrt(1-t*t)-1):.5*(Math.sqrt(1-(t-=2)*t)+1)},easeInElastic:function(t){let e=1.70158,n=0;const i=1;return 0===t?0:1===t?1:(n||(n=.3),e=n/mr*Math.asin(1/i),-i*Math.pow(2,10*(t-=1))*Math.sin((t-e)*mr/n))},easeOutElastic:function(t){let e=1.70158,n=0;const i=1;return 0===t?0:1===t?1:(n||(n=.3),e=n/mr*Math.asin(1/i),i*Math.pow(2,-10*t)*Math.sin((t-e)*mr/n)+1)},easeInOutElastic:function(t){let e=1.70158,n=0;const i=1;return 0===t?0:2==(t/=.5)?1:(n||(n=.45),e=n/mr*Math.asin(1/i),t<1?i*Math.pow(2,10*(t-=1))*Math.sin((t-e)*mr/n)*-.5:i*Math.pow(2,-10*(t-=1))*Math.sin((t-e)*mr/n)*.5+1)},easeInBack:function(t){const e=1.70158;return t*t*((e+1)*t-e)},easeOutBack:function(t){const e=1.70158;return(t-=1)*t*((e+1)*t+e)+1},easeInOutBack:function(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:function(t){return 1-ha.easeOutBounce(1-t)},easeOutBounce:function(t){return t<1/2.75?7.5625*t*t:t<2/2.75?7.5625*(t-=1.5/2.75)*t+.75:t<2.5/2.75?7.5625*(t-=2.25/2.75)*t+.9375:7.5625*(t-=2.625/2.75)*t+.984375},easeInOutBounce:function(t){return t<.5?.5*ha.easeInBounce(2*t):.5*ha.easeOutBounce(2*t-1)+.5}};const fa={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},da="0123456789ABCDEF",pa=function(t){return da[15&t]},ga=function(t){return da[(240&t)>>4]+da[15&t]},ma=function(t){return(240&t)>>4==(15&t)},ba=function(t,e,n){return Math.max(Math.min(t,n),e)},xa=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/,ya=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/,_a={x:"dark",Z:"light",Y:"re",X:"blu",W:"gr",V:"medium",U:"slate",A:"ee",T:"ol",S:"or",B:"ra",C:"lateg",D:"ights",R:"in",Q:"turquois",E:"hi",P:"ro",O:"al",N:"le",M:"de",L:"yello",F:"en",K:"ch",G:"arks",H:"ea",I:"ightg",J:"wh"},va={OiceXe:"f0f8ff",antiquewEte:"faebd7",aqua:"ffff",aquamarRe:"7fffd4",azuY:"f0ffff",beige:"f5f5dc",bisque:"ffe4c4",black:"0",blanKedOmond:"ffebcd",Xe:"ff",XeviTet:"8a2be2",bPwn:"a52a2a",burlywood:"deb887",caMtXe:"5f9ea0",KartYuse:"7fff00",KocTate:"d2691e",cSO:"ff7f50",cSnflowerXe:"6495ed",cSnsilk:"fff8dc",crimson:"dc143c",cyan:"ffff",xXe:"8b",xcyan:"8b8b",xgTMnPd:"b8860b",xWay:"a9a9a9",xgYF:"6400",xgYy:"a9a9a9",xkhaki:"bdb76b",xmagFta:"8b008b",xTivegYF:"556b2f",xSange:"ff8c00",xScEd:"9932cc",xYd:"8b0000",xsOmon:"e9967a",xsHgYF:"8fbc8f",xUXe:"483d8b",xUWay:"2f4f4f",xUgYy:"2f4f4f",xQe:"ced1",xviTet:"9400d3",dAppRk:"ff1493",dApskyXe:"bfff",dimWay:"696969",dimgYy:"696969",dodgerXe:"1e90ff",fiYbrick:"b22222",flSOwEte:"fffaf0",foYstWAn:"228b22",fuKsia:"ff00ff",gaRsbSo:"dcdcdc",ghostwEte:"f8f8ff",gTd:"ffd700",gTMnPd:"daa520",Way:"808080",gYF:"8000",gYFLw:"adff2f",gYy:"808080",honeyMw:"f0fff0",hotpRk:"ff69b4",RdianYd:"cd5c5c",Rdigo:"4b0082",ivSy:"fffff0",khaki:"f0e68c",lavFMr:"e6e6fa",lavFMrXsh:"fff0f5",lawngYF:"7cfc00",NmoncEffon:"fffacd",ZXe:"add8e6",ZcSO:"f08080",Zcyan:"e0ffff",ZgTMnPdLw:"fafad2",ZWay:"d3d3d3",ZgYF:"90ee90",ZgYy:"d3d3d3",ZpRk:"ffb6c1",ZsOmon:"ffa07a",ZsHgYF:"20b2aa",ZskyXe:"87cefa",ZUWay:"778899",ZUgYy:"778899",ZstAlXe:"b0c4de",ZLw:"ffffe0",lime:"ff00",limegYF:"32cd32",lRF:"faf0e6",magFta:"ff00ff",maPon:"800000",VaquamarRe:"66cdaa",VXe:"cd",VScEd:"ba55d3",VpurpN:"9370db",VsHgYF:"3cb371",VUXe:"7b68ee",VsprRggYF:"fa9a",VQe:"48d1cc",VviTetYd:"c71585",midnightXe:"191970",mRtcYam:"f5fffa",mistyPse:"ffe4e1",moccasR:"ffe4b5",navajowEte:"ffdead",navy:"80",Tdlace:"fdf5e6",Tive:"808000",TivedBb:"6b8e23",Sange:"ffa500",SangeYd:"ff4500",ScEd:"da70d6",pOegTMnPd:"eee8aa",pOegYF:"98fb98",pOeQe:"afeeee",pOeviTetYd:"db7093",papayawEp:"ffefd5",pHKpuff:"ffdab9",peru:"cd853f",pRk:"ffc0cb",plum:"dda0dd",powMrXe:"b0e0e6",purpN:"800080",YbeccapurpN:"663399",Yd:"ff0000",Psybrown:"bc8f8f",PyOXe:"4169e1",saddNbPwn:"8b4513",sOmon:"fa8072",sandybPwn:"f4a460",sHgYF:"2e8b57",sHshell:"fff5ee",siFna:"a0522d",silver:"c0c0c0",skyXe:"87ceeb",UXe:"6a5acd",UWay:"708090",UgYy:"708090",snow:"fffafa",sprRggYF:"ff7f",stAlXe:"4682b4",tan:"d2b48c",teO:"8080",tEstN:"d8bfd8",tomato:"ff6347",Qe:"40e0d0",viTet:"ee82ee",JHt:"f5deb3",wEte:"ffffff",wEtesmoke:"f5f5f5",Lw:"ffff00",LwgYF:"9acd32"};let wa;const Ma=function(){function t(e){if(e instanceof t)return e;const n=typeof e;let i;"object"===n?i=Xe(e):"string"===n&&(i=ve(e)||je(e)||$e(e)),this._rgb=i,this._valid=!!i}const n=t.prototype;return n.rgbString=function(){return this._valid?Te(this._rgb):this._rgb},n.hexString=function(){return this._valid?we(this._rgb):this._rgb},n.hslString=function(){return this._valid?Ne(this._rgb):this._rgb},n.mix=function(t,e){const n=this;if(t){const i=n.rgb,o=t.rgb;let r;const a=e===r?.5:e,s=2*a-1,l=i.a-o.a,c=((s*l==-1?s:(s+l)/(1+s*l))+1)/2;r=1-c,i.r=255&c*i.r+r*o.r+.5,i.g=255&c*i.g+r*o.g+.5,i.b=255&c*i.b+r*o.b+.5,i.a=a*i.a+(1-a)*o.a,n.rgb=i}return n},n.clone=function(){return new t(this.rgb)},n.alpha=function(t){return this._rgb.a=Se(t),this},n.clearer=function(t){const e=this._rgb;return e.a*=1-t,this},n.greyscale=function(){const t=this._rgb,e=Me(.3*t.r+.59*t.g+.11*t.b);return t.r=t.g=t.b=e,this},n.opaquer=function(t){const e=this._rgb;return e.a*=1+t,this},n.negate=function(){const t=this._rgb;return t.r=255-t.r,t.g=255-t.g,t.b=255-t.b,this},n.lighten=function(t){return Ye(this._rgb,2,t),this},n.darken=function(t){return Ye(this._rgb,2,-t),this},n.saturate=function(t){return Ye(this._rgb,1,t),this},n.desaturate=function(t){return Ye(this._rgb,1,-t),this},n.rotate=function(t){return We(this._rgb,t),this},e(t,[{key:"valid",get:function(){return this._valid}},{key:"rgb",get:function(){const t=Ue(this._rgb);return t&&(t.a=Pe(t.a)),t},set:function(t){this._rgb=Xe(t)}}]),t}(),ka=function(t){return t instanceof CanvasGradient||t instanceof CanvasPattern},Sa="transparent",Pa={boolean:function(t,e,n){return n>.5?e:t},color:function(t,e,n){const i=qe(t||Sa),o=i.valid&&qe(e||Sa);return o&&o.valid?o.mix(i,n).hexString():e},number:function(t,e,n){return t+(e-t)*n}},Da=function(){function t(t,e,n,i){const o=e[n];i=Dt([t.to,i,o,t.from]);const r=Dt([t.from,o,i]);this._active=!0,this._fn=t.fn||Pa[t.type||typeof r],this._easing=ha[t.easing||"linear"],this._start=Math.floor(Date.now()+(t.delay||0)),this._duration=Math.floor(t.duration),this._loop=!!t.loop,this._target=e,this._prop=n,this._from=r,this._to=i,this._promises=void 0}const e=t.prototype;return e.active=function(){return this._active},e.update=function(t,e,n){const i=this;if(i._active){const o=i._target[i._prop],r=n-i._start,a=i._duration-r;i._start=n,i._duration=Math.floor(Math.max(a,t.duration)),i._loop=!!t.loop,i._to=Dt([t.to,e,o,t.from]),i._from=Dt([t.from,o,e])}},e.cancel=function(){const t=this;t._active&&(t.tick(Date.now()),t._active=!1,t._notify(!1))},e.tick=function(t){const e=this,n=t-e._start,i=e._duration,o=e._prop,r=e._from,a=e._loop,s=e._to;let l;if(e._active=r!==s&&(a||n1?2-l:l,l=e._easing(Math.min(1,Math.max(0,l))),e._target[o]=e._fn(r,s,l))},e.wait=function(){const t=this._promises||(this._promises=[]);return new de(function(e,n){t.push({res:e,rej:n})})},e._notify=function(t){const e=t?"res":"rej",n=this._promises||[];for(let t=0;t=0;--s){const l=r[s];if("$"===l.charAt(0))continue;if("options"===l){i.push.apply(i,this._animateOptions(t,e));continue}const c=e[l];let u=o[l];const h=n.get(l);if(u){if(h&&u.active()){u.update(h,c,a);continue}u.cancel()}h&&h.duration?(o[l]=u=new Da(h,t,l,c),i.push(u)):t[l]=c}return i},e.update=function(t,e){if(0===this._properties.size)return Ze(t,e),void n(t,e);const i=this._createAnimations(t,e);return i.length?(ur.add(this._chart,i),!0):void 0},t}(),Ea=function(t){return h(t)?t:Object.keys(t)},La=function(t,e){return e?"hover"+S(t):t},Ca=function(t){return"reset"===t||"none"===t},Ra=function(t,e){return e?t:n({},t)},Fa=function(t,e){return e?Object.freeze(t):t},za=function(){function t(t,e){this.chart=t,this._ctx=t.ctx,this.index=e,this._cachedAnimations={},this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this._config=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.$context=void 0,this.initialize()}const e=t.prototype;return e.initialize=function(){const t=this,e=t._cachedMeta;t.configure(),t.linkScales(),e._stacked=ln(e.vScale,e),t.addElements()},e.updateIndex=function(t){this.index=t},e.linkScales=function(){const t=this,e=t.chart,n=t._cachedMeta,i=t.getDataset(),o=function(t,e,n,i){return"x"===t?e:"r"===t?i:n},r=n.xAxisID=d(i.xAxisID,dn(e,"x")),a=n.yAxisID=d(i.yAxisID,dn(e,"y")),s=n.rAxisID=d(i.rAxisID,dn(e,"r")),l=n.indexAxis,c=n.iAxisID=o(l,r,a,s),u=n.vAxisID=o(l,a,r,s);n.xScale=t.getScaleForId(r),n.yScale=t.getScaleForId(a),n.rScale=t.getScaleForId(s),n.iScale=t.getScaleForId(c),n.vScale=t.getScaleForId(u)},e.getDataset=function(){return this.chart.data.datasets[this.index]},e.getMeta=function(){return this.chart.getDatasetMeta(this.index)},e.getScaleForId=function(t){return this.chart.scales[t]},e._getOtherScale=function(t){const e=this._cachedMeta;return t===e.iScale?e.vScale:e.iScale},e.reset=function(){this._update("reset")},e._destroy=function(){const t=this._cachedMeta;this._data&&nt(this._data,this),t._stacked&&mn(t)},e._dataCheck=function(){const t=this,e=t.getDataset(),n=e.data||(e.data=[]);f(n)?t._data=sn(n):t._data!==n&&(t._data&&nt(t._data,t),n&&Object.isExtensible(n)&&et(n,t),t._data=n)},e.addElements=function(){const t=this,e=t._cachedMeta;t._dataCheck();const n=t._data,i=e.data=new Array(n.length);for(let e=0,o=n.length;e0&&(g=i._sorted,p=i._parsed[t-1]),!1===n._parsing)i._parsed=o,i._sorted=!0;else{u=h(o[t])?n.parseArrayData(i,o,t,e):f(o[t])?n.parseObjectData(i,o,t,e):n.parsePrimitiveData(i,o,t,e);const r=function(){return isNaN(d[l])||p&&d[l]b||d=0;--p)if(!n()){i.updateRangeFromParsed(u,t,m,c);break}return u},e.getAllParsedValues=function(t){const e=this._cachedMeta._parsed,n=[];let i,o,r;for(i=0,o=e.length;i=0;a--)r=o[a],e[r]=Ge(i[r])},e.getStyle=function(t,e){const n=this,i=n._cachedMeta,o=i.dataset;n._config||n.configure();const r=o&&void 0===t?n.resolveDatasetElementOptions(e):n.resolveDataElementOptions(t||0,e&&"active");return e&&n._addAutomaticHoverColors(t,r),r},e.getContext=function(t,e){const n=this;let i;if(t>=0&&te?t._insertElements(e,n-e):n1e15)&&(a="scientific");let s=i.length>3?i[2].value-i[1].value:i[1].value-i[0].value;Math.abs(s)>1&&t!==Math.floor(t)&&(s=t-Math.floor(t));const l=Mr(Math.abs(s)),c=Math.max(Math.min(-1*Math.floor(l),20),0),u={notation:a,minimumFractionDigits:c,maximumFractionDigits:c};n(u,this.options.ticks.format);const h=o+JSON.stringify(u);let f=Ba.get(h);return f||(f=new Intl.NumberFormat(o,u),Ba.set(h,f)),f.format(t)},logarithmic:function(t,e,n){if(0===t)return"0";const i=t/Math.pow(10,Math.floor(Mr(t)));return 1===i||2===i||5===i?Va.numeric.call(this,t,e,n):""}},Wa={formatters:Va};pr.set("scale",{display:!0,offset:!1,reverse:!1,beginAtZero:!1,gridLines:{display:!0,color:"rgba(0,0,0,0.1)",lineWidth:1,drawBorder:!0,drawOnChartArea:!0,drawTicks:!0,tickMarkLength:10,offsetGridLines:!1,borderDash:[],borderDashOffset:0},scaleLabel:{display:!1,labelString:"",padding:{top:4,bottom:4}},ticks:{minRotation:0,maxRotation:50,mirror:!1,lineWidth:0,strokeStyle:"",padding:0,display:!0,autoSkip:!0,autoSkipPadding:0,labelOffset:0,callback:Wa.formatters.values,minor:{},major:{},align:"center",crossAlign:"near"}});const Na=function(t){function e(e){let n;return n=t.call(this)||this,n.id=e.id,n.type=e.type,n.options=void 0,n.ctx=e.ctx,n.chart=e.chart,n.top=void 0,n.bottom=void 0,n.left=void 0,n.right=void 0,n.width=void 0,n.height=void 0,n._margins={left:0,right:0,top:0,bottom:0},n.maxWidth=void 0,n.maxHeight=void 0,n.paddingTop=void 0,n.paddingBottom=void 0,n.paddingLeft=void 0,n.paddingRight=void 0,n.axis=void 0,n.labelRotation=void 0,n.min=void 0,n.max=void 0,n.ticks=[],n._gridLineItems=null,n._labelItems=null,n._labelSizes=null,n._length=0,n._longestTextCache={},n._startPixel=void 0,n._endPixel=void 0,n._reversePixels=!1,n._userMax=void 0,n._userMin=void 0,n._ticksLength=0,n._borderValue=0,n._cache={},n.$context=void 0,n}i(e,t);const o=e.prototype;return o.init=function(t){const e=this;e.options=t,e.axis=e.isHorizontal()?"x":"y",e._userMin=e.parse(t.min),e._userMax=e.parse(t.max)},o.parse=function(t,e){return t},o.getUserBounds=function(){let t=this._userMin,e=this._userMax;return(u(t)||isNaN(t))&&(t=Number.POSITIVE_INFINITY),(u(e)||isNaN(e))&&(e=Number.NEGATIVE_INFINITY),{min:t,max:e,minDefined:fr(t),maxDefined:fr(e)}},o.getMinMax=function(t){const e=this;let n,i=e.getUserBounds(),o=i.min,r=i.max,a=i.minDefined,s=i.maxDefined;if(a&&s)return{min:o,max:r};const l=e.getMatchingVisibleMetas();for(let i=0,c=l.length;i=r||i<=1||!t.isHorizontal())return void(t.labelRotation=o);const u=t._getLabelSizes(),h=u.widest.width,f=u.highest.height-u.highest.offset,d=Math.min(t.maxWidth,t.chart.width-h);a=e.offset?t.maxWidth/i:d/(i-1),h+6>a&&(a=d/(i-(e.offset?.5:1)),s=t.maxHeight-_n(e.gridLines)-n.padding-vn(e.scaleLabel,t.chart.options.font),l=Math.sqrt(h*h+f*f),c=C(Math.min(Math.asin(Math.min((u.highest.height+6)/a,1)),Math.asin(Math.min(s/l,1))-Math.asin(f/l))),c=Math.max(o,Math.min(r,c))),t.labelRotation=c},o.afterCalculateLabelRotation=function(){p(this.options.afterCalculateLabelRotation,[this])},o.beforeFit=function(){p(this.options.beforeFit,[this])},o.fit=function(){const t=this,e={width:0,height:0},n=t.chart,i=t.options,o=i.ticks,r=i.scaleLabel,a=i.gridLines,s=t._isVisible(),l="top"!==i.position&&"x"===t.axis,c=t.isHorizontal(),u=s&&vn(r,n.options.font);if(c?e.width=t.maxWidth:s&&(e.width=_n(a)+u),c?s&&(e.height=_n(a)+u):e.height=t.maxHeight,o.display&&s&&t.ticks.length){const n=t._getLabelSizes(),i=n.first,r=n.last,a=n.widest,s=n.highest,u=.8*s.offset,h=o.padding;if(c){const n=0!==t.labelRotation,c=L(t.labelRotation),f=Math.cos(c),d=Math.sin(c),p=d*a.width+f*(s.height-(n?s.offset:0))+(n?0:u);e.height=Math.min(t.maxHeight,e.height+p+h);const g=t.getPixelForTick(0)-t.left,m=t.right-t.getPixelForTick(t.ticks.length-1);let b,x;n?(b=l?f*i.width+d*i.offset:d*(i.height-i.offset),x=l?d*(r.height-r.offset):f*r.width+d*r.offset):"start"===o.align?(b=0,x=r.width):"end"===o.align?(b=i.width,x=0):(b=i.width/2,x=r.width/2),t.paddingLeft=Math.max((b-g)*t.width/(t.width-g),0)+3,t.paddingRight=Math.max((x-m)*t.width/(t.width-m),0)+3}else{const n=o.mirror?0:a.width+h+u;e.width=Math.min(t.maxWidth,e.width+n);let s=r.height/2,l=i.height/2;"start"===o.align?(s=0,l=i.height):"end"===o.align&&(s=r.height,l=0),t.paddingTop=s,t.paddingBottom=l}}t._handleMargins(),c?(t.width=t._length=n.width-t._margins.left-t._margins.right,t.height=e.height):(t.width=e.width,t.height=t._length=n.height-t._margins.top-t._margins.bottom)},o._handleMargins=function(){const t=this;t._margins&&(t._margins.left=Math.max(t.paddingLeft,t._margins.left),t._margins.top=Math.max(t.paddingTop,t._margins.top),t._margins.right=Math.max(t.paddingRight,t._margins.right),t._margins.bottom=Math.max(t.paddingBottom,t._margins.bottom))},o.afterFit=function(){p(this.options.afterFit,[this])},o.isHorizontal=function(){const t=this.options,e=t.axis,n=t.position;return"top"===n||"bottom"===n||"x"===e},o.isFullWidth=function(){return this.options.fullWidth},o._convertTicksToLabels=function(t){const e=this;e.beforeTickToLabelConversion(),e.generateTickLabels(t),e.afterTickToLabelConversion()},o._getLabelSizes=function(){const t=this;let e=t._labelSizes;return e||(t._labelSizes=e=t._computeLabelSizes()),e},o._computeLabelSizes=function(){function t(t){return{width:r[t]||0,height:a[t]||0,offset:s[t]||0}}const e=this,n=e.ctx,i=e._longestTextCache,o=e.options.ticks.sampleSize,r=[],a=[],s=[];let l=0,c=0,f=e.ticks;oe.length-1?null:this.getPixelForValue(e[t].value)},o.getPixelForDecimal=function(t){const e=this;return e._reversePixels&&(t=1-t),N(e._startPixel+t*e._length)},o.getDecimalForPixel=function(t){const e=(t-this._startPixel)/this._length;return this._reversePixels?1-e:e},o.getBasePixel=function(){return this.getPixelForValue(this.getBaseValue())},o.getBaseValue=function(){const t=this.min,e=this.max;return t<0&&e<0?e:t>0&&e>0?t:0},o.getContext=function(t){const e=this,n=e.ticks||[];if(t>=0&&ti)return Sn(t,l,o,r/i),l;const c=Mn(o,t,i);if(r>0){let e,n;const i=r>1?Math.round((s-a)/(r-1)):null;for(Pn(t,l,c,u(i)?0:a-i,a),e=0,n=r-1;es*o?s/i:l/o:l*o0},o._computeGridLineItems=function(t){const e=this,n=e.axis,i=e.chart,o=e.options,r=o.gridLines,a=o.position,s=r.offsetGridLines,l=e.isHorizontal(),c=e.ticks,u=c.length+(s?1:0),h=_n(r),d=[];let p=this.getContext(0);const g=r.drawBorder?Dt([r.borderWidth,r.lineWidth,0],p,0):0,m=g/2,b=function(t){return U(i,t,g)};let x,y,_,v,w,M,k,S,P,D,A,T;if("top"===a)x=b(e.bottom),M=e.bottom-h,S=x-m,D=b(t.top)+m,T=t.bottom;else if("bottom"===a)x=b(e.top),D=t.top,T=b(t.bottom)-m,M=x+m,S=e.top+h;else if("left"===a)x=b(e.right),w=e.right-h,k=x-m,P=b(t.left)+m,A=t.right;else if("right"===a)x=b(e.left),P=t.left,A=b(t.right)-m,w=x+m,k=e.left+h;else if("x"===n){if("center"===a)x=b((t.top+t.bottom)/2);else if(f(a)){const t=Object.keys(a)[0],n=a[t];x=b(e.chart.scales[t].getPixelForValue(n))}D=t.top,T=t.bottom,M=x+m,S=M+h}else if("y"===n){if("center"===a)x=b((t.left+t.right)/2);else if(f(a)){const t=Object.keys(a)[0],n=a[t];x=b(e.chart.scales[t].getPixelForValue(n))}w=x-m,k=w-h,P=t.left,A=t.right}for(y=0;y0&&""!==e.strokeStyle;i.save(),i.translate(t.x,t.y),i.rotate(t.rotation),i.font=e.string,i.fillStyle=e.color,i.textAlign=t.textAlign,i.textBaseline=t.textBaseline,n&&(i.strokeStyle=e.strokeStyle,i.lineWidth=e.lineWidth);const s=t.label;let c=t.textOffset;if(h(s))for(a=0,l=s.length;an){for(let e=n;e=0;--n)t._drawDataset(e[n]);t._plugins.notify(t,"afterDatasetsDraw")},i._drawDataset=function(t){const e=this,n=e.ctx,i=t._clip,o=e.chartArea,r={meta:t,index:t.index};!1!==e._plugins.notify(e,"beforeDatasetDraw",[r])&&(q(n,{left:!1===i.left?0:o.left-i.left,right:!1===i.right?e.width:o.right+i.right,top:!1===i.top?0:o.top-i.top,bottom:!1===i.bottom?e.height:o.bottom+i.bottom}),t.controller.draw(),G(n),e._plugins.notify(e,"afterDatasetDraw",[r]))},i.getElementsAtEventForMode=function(t,e,n,i){const o=Er.modes[e];return"function"==typeof o?o(this,t,n,i):[]},i.getDatasetMeta=function(t){const e=this,n=e.data.datasets[t],i=e._metasets;let o=i.filter(function(t){return t&&t._dataset===n}).pop();return o||(o=i[t]={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:n.order||0,index:t,_dataset:n,_parsed:[],_sorted:!1}),o},i.getContext=function(){return this.$context||(this.$context=Object.create(null,{chart:{value:this},type:{value:"chart"}}))},i.getVisibleDatasetCount=function(){return this.getSortedVisibleDatasetMetas().length},i.isDatasetVisible=function(t){const e=this.data.datasets[t];if(!e)return!1;const n=this.getDatasetMeta(t);return"boolean"==typeof n.hidden?!n.hidden:!e.hidden},i.setDatasetVisibility=function(t,e){const n=this.getDatasetMeta(t);n.hidden=!e},i.toggleDataVisibility=function(t){this._hiddenIndices[t]=!this._hiddenIndices[t]},i.getDataVisibility=function(t){return!this._hiddenIndices[t]},i._updateDatasetVisibility=function(t,e){const n=this,i=e?"show":"hide",o=n.getDatasetMeta(t),r=o.controller._resolveAnimations(void 0,i);n.setDatasetVisibility(t,e),r.update(o,{visible:e}),n.update(function(e){return e.datasetIndex===t?i:void 0})},i.hide=function(t){this._updateDatasetVisibility(t,!1)},i.show=function(t){this._updateDatasetVisibility(t,!0)},i._destroyDatasetMeta=function(t){const e=this,n=e._metasets&&e._metasets[t];n&&(n.controller._destroy(),delete e._metasets[t])},i.destroy=function(){const e=this,n=e.canvas;let i,o;for(e.stop(),ur.remove(e),i=0,o=e.data.datasets.length;i=0;--t)i=Math.max(i,n[t].size());return i>0&&i},o.getLabelAndValue=function(t){const e=this,n=e._cachedMeta,i=n.xScale,o=n.yScale,r=e.getParsed(t),a=i.getLabelForValue(r.x),s=o.getLabelForValue(r.y),l=r._custom;return{label:n.label,value:"("+a+", "+s+(l?", "+l:"")+")"}},o.update=function(t){const e=this,n=e._cachedMeta.data;e.updateElements(n,0,n.length,t)},o.updateElements=function(t,e,n,i){const o=this,r="reset"===i,a=o._cachedMeta,s=a.xScale,l=a.yScale,c=o.resolveDataElementOptions(e,i),u=o.getSharedOptions(c),h=o.includeOptions(i,u);for(let a=e;a0&&!isNaN(t)?mr*(Math.abs(t)/e):0},n.getLabelAndValue=function(t){const e=this,n=e._cachedMeta,i=e.chart,o=i.data.labels||[];return{label:o[t]||"",value:n._parsed[t]}},n.getMaxBorderWidth=function(t){const e=this;let n=0;const i=e.chart;let o,r,a,s,l;if(!t)for(o=0,r=i.data.datasets.length;o0&&o.getParsed(e-1);for(let a=e;a0&&n.x-m.x>g};f&&(p.options=h||o.resolveDataElementOptions(a,i)),o.updateElement(e,a,p,i),m=n}o.updateSharedOptions(h,i,u)},n.resolveDatasetElementOptions=function(e){const n=this,i=n._config,o=n.chart.options,r=o.elements.line,a=t.prototype.resolveDatasetElementOptions.call(this,e),s=d(i.showLine,o.showLine);return a.spanGaps=d(i.spanGaps,o.spanGaps),a.tension=d(i.tension,r.tension),a.stepped=Dt([i.stepped,r.stepped]),s||(a.borderWidth=0),a},n.getMaxOverflow=function(){const t=this,e=t._cachedMeta,n=e.dataset.options.borderWidth||0,i=e.data||[];if(!i.length)return n;const o=i[0].size(),r=i[i.length-1].size();return Math.max(n,o,r)/2},n.draw=function(){this._cachedMeta.dataset.updateControlPoints(this.chart.chartArea),t.prototype.draw.call(this)},e}(za);as.id="line",as.defaults={datasetElementType:"line",datasetElementOptions:["backgroundColor","borderCapStyle","borderColor","borderDash","borderDashOffset","borderJoinStyle","borderWidth","capBezierPoints","cubicInterpolationMode","fill"],dataElementType:"point",dataElementOptions:{backgroundColor:"pointBackgroundColor",borderColor:"pointBorderColor",borderWidth:"pointBorderWidth",hitRadius:"pointHitRadius",hoverHitRadius:"pointHitRadius",hoverBackgroundColor:"pointHoverBackgroundColor",hoverBorderColor:"pointHoverBorderColor",hoverBorderWidth:"pointHoverBorderWidth",hoverRadius:"pointHoverRadius",pointStyle:"pointStyle",radius:"pointRadius",rotation:"pointRotation"},showLine:!0,spanGaps:!1,interaction:{mode:"index"},hover:{},scales:{_index_:{type:"category"},_value_:{type:"linear"}}};const ss=function(t){function e(e,n){let i;return i=t.call(this,e,n)||this,i.innerRadius=void 0,i.outerRadius=void 0,i}i(e,t);const n=e.prototype;return n.update=function(t){const e=this._cachedMeta.data;this._updateRadius(),this.updateElements(e,0,e.length,t)},n._updateRadius=function(){const t=this,e=t.chart,n=e.chartArea,i=e.options,o=Math.min(n.right-n.left,n.bottom-n.top),r=Math.max(o/2,0),a=Math.max(i.cutoutPercentage?r/100*i.cutoutPercentage:1,0),s=(r-a)/e.getVisibleDatasetCount();t.outerRadius=r-s*t.index,t.innerRadius=t.outerRadius-s},n.updateElements=function(t,e,n,i){const o=this,r="reset"===i,a=o.chart,s=o.getDataset(),l=a.options,c=l.animation,u=o._cachedMeta.rScale,h=u.xCenter,f=u.yCenter,d=Pi(l.startAngle);let p,g=d;for(o._cachedMeta.count=o.countVisibleElements(),p=0;p=mr||V(r,l,c),p=a>=u&&a<=h;return d&&p},o.getCenterPoint=function(t){const e=this.getProps(["x","y","startAngle","endAngle","innerRadius","outerRadius"],t),n=e.x,i=e.y,o=e.startAngle,r=e.endAngle,a=e.innerRadius,s=e.outerRadius,l=(o+r)/2,c=(a+s)/2;return{x:n+Math.cos(l)*c,y:i+Math.sin(l)*c}},o.tooltipPosition=function(t){return this.getCenterPoint(t)},o.draw=function(t){const e=this,n=e.options,i=n.offset||0;if(e.pixelMargin="inner"===n.borderAlign?.33:0,e.fullCircles=Math.floor(e.circumference/mr),0!==e.circumference){if(t.save(),i&&e.circumference=0;--i)o=e[i].$filler,o&&o.line.updateControlPoints(n)},beforeDatasetDraw:function(t,e){const n=t.chartArea,i=t.ctx,o=e.meta.$filler;if(!o||!1===o.fill)return;const r=uo(o),a=o.line,s=o.scale,l=a.options,c=l.fill,u=l.backgroundColor,h=c||{},f=h.above,d=void 0===f?u:f,p=h.below,g=void 0===p?u:p;r&&a.points.length&&(q(i,n),vo(i,{line:a,target:r,above:d,below:g,area:n,scale:s}),G(i))},defaults:{propagate:!0}},_s=function(t){function e(e){let i;return i=t.call(this)||this,n(r(i),e),i.legendHitBoxes=[],i._hoveredItem=null,i.doughnutMode=!1,i.chart=e.chart,i.options=e.options,i.ctx=e.ctx,i.legendItems=void 0,i.columnWidths=void 0,i.columnHeights=void 0,i.lineWidths=void 0,i._minSize=void 0,i.maxHeight=void 0,i.maxWidth=void 0,i.top=void 0,i.bottom=void 0,i.left=void 0,i.right=void 0,i.height=void 0,i.width=void 0,i._margins=void 0,i.paddingTop=void 0,i.paddingBottom=void 0,i.paddingLeft=void 0,i.paddingRight=void 0,i.position=void 0,i.weight=void 0,i.fullWidth=void 0,i}i(e,t);const o=e.prototype;return o.beforeUpdate=function(){},o.update=function(t,e,n){const i=this;i.beforeUpdate(),i.maxWidth=t,i.maxHeight=e,i._margins=n,i.beforeSetDimensions(),i.setDimensions(),i.afterSetDimensions(),i.beforeBuildLabels(),i.buildLabels(),i.afterBuildLabels(),i.beforeFit(),i.fit(),i.afterFit(),i.afterUpdate()},o.afterUpdate=function(){},o.beforeSetDimensions=function(){},o.setDimensions=function(){const t=this;t.isHorizontal()?(t.width=t.maxWidth,t.left=0,t.right=t.width):(t.height=t.maxHeight,t.top=0,t.bottom=t.height),t.paddingLeft=0,t.paddingTop=0,t.paddingRight=0,t.paddingBottom=0,t._minSize={width:0,height:0}},o.afterSetDimensions=function(){},o.beforeBuildLabels=function(){},o.buildLabels=function(){const t=this,e=t.options.labels||{};let n=p(e.generateLabels,[t.chart],t)||[];e.filter&&(n=n.filter(function(n){return e.filter(n,t.chart.data)})),e.sort&&(n=n.sort(function(n,i){return e.sort(n,i,t.chart.data)})),t.options.reverse&&n.reverse(),t.legendItems=n},o.afterBuildLabels=function(){},o.beforeFit=function(){},o.fit=function(){const t=this,e=t.options,n=e.labels,i=e.display,o=t.ctx,r=Pt(n.font,t.chart.options.font),a=r.size,s=wo(n,a),l=Mo(n,a),c=Math.max(l,a),u=t.legendHitBoxes=[],h=t._minSize,f=t.isHorizontal(),d=t._computeTitleHeight();if(f?(h.width=t.maxWidth,h.height=i?10:0):(h.width=i?10:0,h.height=t.maxHeight),i){if(o.font=r.string,f){const e=t.lineWidths=[0];let i=d;o.textAlign="left",o.textBaseline="middle",t.legendItems.forEach(function(t,r){const l=s+a/2+o.measureText(t.text).width;(0===r||e[e.length-1]+l+2*n.padding>h.width)&&(i+=c+n.padding,e[e.length-(r>0?0:1)]=0),u[r]={left:0,top:0,width:l,height:c},e[e.length-1]+=l+n.padding}),h.height+=i}else{const e=n.padding,i=t.columnWidths=[],r=t.columnHeights=[];let l=n.padding,f=0,p=0;const g=h.height-d;t.legendItems.forEach(function(t,h){const d=s+a/2+o.measureText(t.text).width;h>0&&p+a+2*e>g&&(l+=f+n.padding,i.push(f),r.push(p),f=0,p=0),f=Math.max(f,d),p+=a+e,u[h]={left:0,top:0,width:d,height:c}}),l+=f,i.push(f),r.push(p),h.width+=l}t.width=Math.min(h.width,e.maxWidth||xr),t.height=Math.min(h.height,e.maxHeight||xr)}else t.width=h.width=t.height=h.height=0},o.afterFit=function(){},o.isHorizontal=function(){return"top"===this.options.position||"bottom"===this.options.position},o.draw=function(){const t=this,e=t.options,n=e.labels,i=pr.color,o=t.height,r=t.columnHeights,a=t.width,s=t.lineWidths;if(!e.display)return;t.drawTitle();const l=ii(e.rtl,t.left,t._minSize.width),c=t.ctx,u=Pt(n.font,t.chart.options.font),h=u.color,f=u.size;let p;c.textAlign=l.textAlign("left"),c.textBaseline="middle",c.lineWidth=.5,c.strokeStyle=h,c.fillStyle=h,c.font=u.string;const g=wo(n,f),m=Mo(n,f),b=Math.max(f,m),x=t.legendHitBoxes,y=function(t,e,o){if(isNaN(g)||g<=0||isNaN(m)||m<0)return;c.save();const r=d(o.lineWidth,1);if(c.fillStyle=d(o.fillStyle,i),c.lineCap=d(o.lineCap,"butt"),c.lineDashOffset=d(o.lineDashOffset,0),c.lineJoin=d(o.lineJoin,"miter"),c.lineWidth=r,c.strokeStyle=d(o.strokeStyle,i),c.setLineDash&&c.setLineDash(d(o.lineDash,[])),n&&n.usePointStyle){const n={radius:g*Math.SQRT2/2,pointStyle:o.pointStyle,rotation:o.rotation,borderWidth:r},i=l.xPlus(t,g/2),a=e+f/2;$(c,n,i,a)}else{const n=e+Math.max((f-m)/2,0);c.fillRect(l.leftForLtr(t,g),n,g,m),0!==r&&c.strokeRect(l.leftForLtr(t,g),n,g,m)}c.restore()},_=function(t,e,n,i){const o=f/2,r=l.xPlus(t,g+o),a=e+b/2;c.fillText(n.text,r,a),n.hidden&&(c.beginPath(),c.lineWidth=2,c.moveTo(r,a),c.lineTo(l.xPlus(r,i),a),c.stroke())},v=function(t,i){switch(e.align){case"start":return n.padding;case"end":return t-i;default:return(t-i+n.padding)/2}},w=t.isHorizontal(),M=this._computeTitleHeight();p=w?{x:t.left+v(a,s[0]),y:t.top+n.padding+M,line:0}:{x:t.left+n.padding,y:t.top+v(o,r[0])+M,line:0},oi(t.ctx,e.textDirection);const k=b+n.padding;t.legendItems.forEach(function(e,i){const u=c.measureText(e.text).width,h=g+f/2+u;let d=p.x,m=p.y;l.setWidth(t._minSize.width),w?i>0&&d+h+n.padding>t.left+t._minSize.width&&(m=p.y+=k,p.line++,d=p.x=t.left+v(a,s[p.line])):i>0&&m+k>t.top+t._minSize.height&&(d=p.x=d+t.columnWidths[p.line]+n.padding,p.line++,m=p.y=t.top+v(o,r[p.line]));const b=l.x(d);y(b,m,e),x[i].left=l.leftForLtr(b,x[i].width),x[i].top=m,_(b,m,e,u),w?p.x+=h+n.padding:p.y+=k}),ri(t.ctx,e.textDirection)},o.drawTitle=function(){const t=this,e=t.options,n=e.title,i=Pt(n.font,t.chart.options.font),o=St(n.padding);if(!n.display)return;const r=ii(e.rtl,t.left,t._minSize.width),a=t.ctx,s=n.position;let l,c;const u=i.size/2;let h=t.top+o.top+u,f=t.left,d=t.width;if(this.isHorizontal())switch(d=Math.max.apply(Math,t.lineWidths),e.align){case"start":break;case"end":f=t.right-d;break;default:f=(t.left+t.right)/2-d/2}else{const n=Math.max.apply(Math,t.columnHeights);switch(e.align){case"start":break;case"end":h+=t.height-n;break;default:h+=(t.height-n)/2}}switch(s){case"start":l=f,c="left";break;case"end":l=f+d,c="right";break;default:l=f+d/2,c="center"}a.textAlign=r.textAlign(c),a.textBaseline="middle",a.strokeStyle=i.color,a.fillStyle=i.color,a.font=i.string,a.fillText(n.text,l,h)},o._computeTitleHeight=function(){ -const t=this.options.title,e=Pt(t.font,this.chart.options.font),n=St(t.padding);return t.display?e.lineHeight+n.height:0},o._getLegendItemAt=function(t,e){const n=this;let i,o,r;if(t>=n.left&&t<=n.right&&e>=n.top&&e<=n.bottom)for(r=n.legendHitBoxes,i=0;i=o.left&&t<=o.left+o.width&&e>=o.top&&e<=o.top+o.height)return n.legendItems[i];return null},o.handleEvent=function(t){const e=this,n=e.options,i="mouseup"===t.type?"click":t.type;if("mousemove"===i){if(!n.onHover&&!n.onLeave)return}else{if("click"!==i)return;if(!n.onClick)return}const o=e._getLegendItemAt(t.x,t.y);"click"===i?o&&p(n.onClick,[t,o,e],e):(n.onLeave&&o!==e._hoveredItem&&(e._hoveredItem&&p(n.onLeave,[t,e._hoveredItem,e],e),e._hoveredItem=o),o&&p(n.onHover,[t,o,e],e))},e}(Ia),vs={id:"legend",_element:_s,beforeInit:function(t){const e=ko(t.options.legend);e&&So(t,e)},beforeUpdate:function(t){const e=ko(t.options.legend),n=t.legend;e?n?(Rr.configure(t,n,e),n.options=e):So(t,e):n&&(Rr.removeBox(t,n),delete t.legend)},afterUpdate:function(t){t.legend&&t.legend.buildLabels()},afterEvent:function(t,e){const n=t.legend;n&&n.handleEvent(e)},defaults:{display:!0,position:"top",align:"center",fullWidth:!0,reverse:!1,weight:1e3,onClick:function(t,e,n){const i=e.datasetIndex,o=n.chart;o.isDatasetVisible(i)?(o.hide(i),e.hidden=!0):(o.show(i),e.hidden=!1)},onHover:null,onLeave:null,labels:{boxWidth:40,padding:10,generateLabels:function(t){const e=t.data.datasets,n=t.legend.options.labels,i=n.usePointStyle,o=n.pointStyle;return t._getSortedDatasetMetas().map(function(t){const n=t.controller.getStyle(i?0:void 0),r=f(n.borderWidth)?(d(n.borderWidth.top,0)+d(n.borderWidth.left,0)+d(n.borderWidth.bottom,0)+d(n.borderWidth.right,0))/4:n.borderWidth;return{text:e[t.index].label,fillStyle:n.backgroundColor,hidden:!t.visible,lineCap:n.borderCapStyle,lineDash:n.borderDash,lineDashOffset:n.borderDashOffset,lineJoin:n.borderJoinStyle,lineWidth:r,strokeStyle:n.borderColor,pointStyle:o||n.pointStyle,rotation:n.rotation,datasetIndex:t.index}},this)}},title:{display:!1,position:"center",text:""}}},ws=function(t){function e(e){let i;return i=t.call(this)||this,n(r(i),e),i.chart=e.chart,i.options=e.options,i.ctx=e.ctx,i._margins=void 0,i._padding=void 0,i.top=void 0,i.bottom=void 0,i.left=void 0,i.right=void 0,i.width=void 0,i.height=void 0,i.maxWidth=void 0,i.maxHeight=void 0,i.position=void 0,i.weight=void 0,i.fullWidth=void 0,i}i(e,t);const o=e.prototype;return o.beforeUpdate=function(){},o.update=function(t,e,n){const i=this;i.beforeUpdate(),i.maxWidth=t,i.maxHeight=e,i._margins=n,i.beforeSetDimensions(),i.setDimensions(),i.afterSetDimensions(),i.beforeBuildLabels(),i.buildLabels(),i.afterBuildLabels(),i.beforeFit(),i.fit(),i.afterFit(),i.afterUpdate()},o.afterUpdate=function(){},o.beforeSetDimensions=function(){},o.setDimensions=function(){const t=this;t.isHorizontal()?(t.width=t.maxWidth,t.left=0,t.right=t.width):(t.height=t.maxHeight,t.top=0,t.bottom=t.height)},o.afterSetDimensions=function(){},o.beforeBuildLabels=function(){},o.buildLabels=function(){},o.afterBuildLabels=function(){},o.beforeFit=function(){},o.fit=function(){const t=this,e=t.options,n={},i=t.isHorizontal();if(!e.display)return void(t.width=n.width=t.height=n.height=0);const o=h(e.text)?e.text.length:1;t._padding=St(e.padding);const r=o*Pt(e.font,t.chart.options.font).lineHeight+t._padding.height;t.width=n.width=i?t.maxWidth:r,t.height=n.height=i?r:t.maxHeight},o.afterFit=function(){},o.isHorizontal=function(){const t=this.options.position;return"top"===t||"bottom"===t},o.draw=function(){const t=this,e=t.ctx,n=t.options;if(!n.display)return;const i=Pt(n.font,t.chart.options.font),o=i.lineHeight,r=o/2+t._padding.top;let a=0;const s=t.top,l=t.left,c=t.bottom,u=t.right;let f,d,p,g;if(t.isHorizontal()){switch(n.align){case"start":d=l,g="left";break;case"end":d=u,g="right";break;default:d=l+(u-l)/2,g="center"}p=s+r,f=u-l}else{switch(d="left"===n.position?l+r:u-r,n.align){case"start":p="left"===n.position?c:s,g="left";break;case"end":p="left"===n.position?s:c,g="right";break;default:p=s+(c-s)/2,g="center"}f=c-s,a=gr*("left"===n.position?-.5:.5)}e.save(),e.fillStyle=i.color,e.font=i.string,e.translate(d,p),e.rotate(a),e.textAlign=g,e.textBaseline="middle";const m=n.text;if(h(m)){let t=0;for(let n=0;n0&&e.stroke()},o._updateAnimationTarget=function(){const t=this,e=t._chart,i=t.options,o=t.$animations,r=o&&o.x,a=o&&o.y;if(r||a){const o=ks[i.position].call(t,t._active,t._eventPosition);if(!o)return;const s=t._size=Eo(t),l=n({},o,t._size),c=Lo(e,i,l),u=Fo(i,l,c,e);r._to===u.x&&a._to===u.y||(t.xAlign=c.xAlign,t.yAlign=c.yAlign,t.width=s.width,t.height=s.height,t.caretX=o.x,t.caretY=o.y,t._resolveAnimations().update(t,u))}},o.draw=function(t){const e=this,n=e.options;let i=e.opacity;if(!i)return;e._updateAnimationTarget();const o={width:e.width,height:e.height},r={x:e.x,y:e.y};i=Math.abs(i)<.001?0:i;const a=e.title.length||e.beforeBody.length||e.body.length||e.afterBody.length||e.footer.length;n.enabled&&a&&(t.save(),t.globalAlpha=i,e.drawBackground(r,t,o),oi(t,n.textDirection),r.y+=n.yPadding,e.drawTitle(r,t),e.drawBody(r,t),e.drawFooter(r,t),ri(t,n.textDirection),t.restore())},o.getActiveElements=function(){return this._active||[]},o.setActiveElements=function(t,e){const n=this,i=n._active,o=t.map(function(t){const e=t.datasetIndex,i=t.index,o=n._chart.getDatasetMeta(e);if(!o)throw new Error("Cannot find a dataset at index "+e);return{datasetIndex:e,element:o.data[i],index:i}}),r=!m(i,o),a=n._positionChanged(o,e);(r||a)&&(n._active=o,n._eventPosition=e,n.update(!0))},o.handleEvent=function(t,e){const n=this,i=n.options,o=n._active||[];let r=!1,a=[];"mouseout"!==t.type&&(a=n._chart.getElementsAtEventForMode(t,i.mode,i,e),i.reverse&&a.reverse());const s=n._positionChanged(a,t);return r=e||!m(a,o)||s,r&&(n._active=a,(i.enabled||i.custom)&&(n._eventPosition={x:t.x,y:t.y},n.update(!0))),r},o._positionChanged=function(t,e){const n=this,i=ks[n.options.position].call(n,t,e);return n.caretX!==i.x||n.caretY!==i.y},e}(Ia);Ss.positioners=ks;const Ps={id:"tooltip",_element:Ss,positioners:ks,afterInit:function(t){const e=t.options.tooltips;e&&(t.tooltip=new Ss({_chart:t}))},beforeUpdate:function(t){t.tooltip&&t.tooltip.initialize()},reset:function(t){t.tooltip&&t.tooltip.initialize()},afterDraw:function(t){const e=t.tooltip,n={tooltip:e};!1!==t._plugins.notify(t,"beforeTooltipDraw",[n])&&(e&&e.draw(t.ctx),t._plugins.notify(t,"afterTooltipDraw",[n]))},afterEvent:function(t,e,n){if(t.tooltip){const i=n;t.tooltip.handleEvent(e,i)}},defaults:{enabled:!0,custom:null,position:"average",backgroundColor:"rgba(0,0,0,0.8)",titleFont:{style:"bold",color:"#fff"},titleSpacing:2,titleMarginBottom:6,titleAlign:"left",bodySpacing:2,bodyFont:{color:"#fff"},bodyAlign:"left",footerSpacing:2,footerMarginTop:6,footerFont:{color:"#fff",style:"bold"},footerAlign:"left",yPadding:6,xPadding:6,caretPadding:2,caretSize:5,cornerRadius:6,multiKeyBackground:"#fff",displayColors:!0,borderColor:"rgba(0,0,0,0)",borderWidth:0,animation:{duration:400,easing:"easeOutQuart",numbers:{type:"number",properties:["x","y","width","height","caretX","caretY"]},opacity:{easing:"linear",duration:200}},callbacks:{beforeTitle:c,title:function(t){if(t.length>0){const e=t[0],n=e.chart.data.labels,i=n?n.length:0;if(e.label)return e.label;if(i>0&&e.dataIndex=0&&tn.length-1?null:e.getPixelForValue(n[t].value)},n.getValueForPixel=function(t){const e=this,n=Math.round(e._startValue+e.getDecimalForPixel(t)*e._valueRange);return Math.min(Math.max(n,0),e.ticks.length-1)},n.getBasePixel=function(){return this.bottom},e}(Na);As.id="category",As.defaults={ticks:{callback:As.prototype.getLabelForValue}};const Ts=function(t){function e(e){let n;return n=t.call(this,e)||this,n.start=void 0,n.end=void 0,n._startValue=void 0,n._endValue=void 0,n._valueRange=0,n}i(e,t);const n=e.prototype;return n.parse=function(t,e){return u(t)?NaN:("number"==typeof t||t instanceof Number)&&!isFinite(+t)?NaN:+t},n.handleTickRangeOptions=function(){const t=this,e=t.options;if(e.beginAtZero){const e=kr(t.min),n=kr(t.max);e<0&&n<0?t.max=0:e>0&&n>0&&(t.min=0)}const n=void 0!==e.min||void 0!==e.suggestedMin,i=void 0!==e.max||void 0!==e.suggestedMax;void 0!==e.min?t.min=e.min:void 0!==e.suggestedMin&&(null===t.min?t.min=e.suggestedMin:t.min=Math.min(t.min,e.suggestedMin)),void 0!==e.max?t.max=e.max:void 0!==e.suggestedMax&&(null===t.max?t.max=e.suggestedMax:t.max=Math.max(t.max,e.suggestedMax)),n!==i&&t.min>=t.max&&(n?t.max=t.min+1:t.min=t.max-1),t.min===t.max&&(t.max++,e.beginAtZero||t.min--)},n.getTickLimit=function(){const t=this,e=t.options.ticks;let n,i=e.maxTicksLimit,o=e.stepSize;return o?n=Math.ceil(t.max/o)-Math.floor(t.min/o)+1:(n=t.computeTickLimit(),i=i||11),i&&(n=Math.min(i,n)),n},n.computeTickLimit=function(){return Number.POSITIVE_INFINITY},n.buildTicks=function(){const t=this,e=t.options,n=e.ticks;let i=t.getTickLimit();i=Math.max(2,i);const o={maxTicks:i,min:e.min,max:e.max,precision:n.precision,stepSize:d(n.fixedStepSize,n.stepSize)},r=Vo(o,t);return E(r,t,"value"),e.reverse?(r.reverse(),t.start=t.max,t.end=t.min):(t.start=t.min,t.end=t.max),r},n.configure=function(){const e=this,n=e.ticks;let i=e.min,o=e.max;if(t.prototype.configure.call(this),e.options.offset&&n.length){const t=(o-i)/Math.max(n.length-1,1)/2;i-=t,o+=t}e._startValue=i,e._endValue=o,e._valueRange=o-i},n.getLabelForValue=function(t){return new Intl.NumberFormat(this.options.locale).format(t)},e}(Na),Os=function(t){function e(){return t.apply(this,arguments)||this}i(e,t);const n=e.prototype;return n.determineDataLimits=function(){const t=this,e=t.options,n=t.getMinMax(!0),i=n.min,o=n.max;t.min=fr(i)?i:d(e.suggestedMin,0),t.max=fr(o)?o:d(e.suggestedMax,1),e.stacked&&i>0&&(t.min=0),t.handleTickRangeOptions()},n.computeTickLimit=function(){const t=this;if(t.isHorizontal())return Math.ceil(t.width/40);const e=t._resolveTickFontOptions(0);return Math.ceil(t.height/e.lineHeight)},n.getPixelForValue=function(t){const e=this;return e.getPixelForDecimal((t-e._startValue)/e._valueRange)},n.getValueForPixel=function(t){return this._startValue+this.getDecimalForPixel(t)*this._valueRange},e}(Ts);Os.id="linear",Os.defaults={ticks:{callback:Wa.formatters.numeric}};const Es=function(t){function e(e){let n;return n=t.call(this,e)||this,n.start=void 0,n.end=void 0,n._startValue=void 0,n._valueRange=0,n}i(e,t);const n=e.prototype;return n.parse=function(t,e){const n=Ts.prototype.parse.apply(this,[t,e]);if(0!==n)return fr(n)&&n>0?n:NaN;this._zero=!0},n.determineDataLimits=function(){const t=this,e=t.getMinMax(!0),n=e.min,i=e.max;t.min=fr(n)?Math.max(0,n):null,t.max=fr(i)?Math.max(0,i):null,t.options.beginAtZero&&(t._zero=!0),t.handleTickRangeOptions()},n.handleTickRangeOptions=function(){const t=this,e=t.options,n=e.suggestedMax,i=e.suggestedMin,o=1,r=10;let a=t.min,s=t.max;u(i)||(a=Math.min(a,i)),u(n)||(s=Math.max(s,n)),a===s&&(a<=0?(a=o,s=r):(a=Math.pow(10,Math.floor(Mr(a))-1),s=Math.pow(10,Math.floor(Mr(s))+1))),a<=0&&(a=Math.pow(10,Math.floor(Mr(s))-1)),s<=0&&(s=Math.pow(10,Math.floor(Mr(a))+1)),!t._userMin&&t._zero&&a===Math.pow(10,Math.floor(Mr(t.min)))&&(a=Math.pow(10,Math.floor(Mr(a))-1)),t.min=a,t.max=s},n.buildTicks=function(){const t=this,e=t.options,n={min:t._userMin,max:t._userMax},i=Ho(n,t);let o=!t.isHorizontal();return E(i,t,"value"),e.reverse?(o=!o,t.start=t.max,t.end=t.min):(t.start=t.min,t.end=t.max),o&&i.reverse(),i},n.getLabelForValue=function(t){return void 0===t?"0":new Intl.NumberFormat(this.options.locale).format(t)},n.configure=function(){const e=this,n=e.min;t.prototype.configure.call(this),e._startValue=Mr(n),e._valueRange=Mr(e.max)-Mr(n)},n.getPixelForValue=function(t){const e=this;return void 0!==t&&0!==t||(t=e.min),e.getPixelForDecimal(t===e.min?0:(Mr(t)-e._startValue)/e._valueRange)},n.getValueForPixel=function(t){const e=this,n=e.getDecimalForPixel(t);return Math.pow(10,e._startValue+n*e._valueRange)},e}(Na);Es.id="logarithmic",Es.defaults={ticks:{callback:Wa.formatters.logarithmic,major:{enabled:!0}}};const Ls=function(t){function e(e){let n;return n=t.call(this,e)||this,n.xCenter=void 0,n.yCenter=void 0,n.drawingArea=void 0,n.pointLabels=[],n}i(e,t);const n=e.prototype;return n.init=function(e){t.prototype.init.call(this,e),this.axis="r"},n.setDimensions=function(){const t=this;t.width=t.maxWidth,t.height=t.maxHeight,t.paddingTop=jo(t.options)/2,t.xCenter=Math.floor(t.width/2),t.yCenter=Math.floor((t.height-t.paddingTop)/2),t.drawingArea=Math.min(t.height-t.paddingTop,t.width)/2},n.determineDataLimits=function(){const t=this,e=t.getMinMax(!1),n=e.min,i=e.max;t.min=fr(n)&&!isNaN(n)?n:0,t.max=fr(i)&&!isNaN(i)?i:0,t.handleTickRangeOptions()},n.computeTickLimit=function(){return Math.ceil(this.drawingArea/jo(this.options))},n.generateTickLabels=function(t){const e=this;Ts.prototype.generateTickLabels.call(e,t),e.pointLabels=e.chart.data.labels.map(function(t,n){const i=p(e.options.pointLabels.callback,[t,n],e);return i||0===i?i:""})},n.fit=function(){const t=this,e=t.options;e.display&&e.pointLabels.display?Xo(t):t.setCenterPoint(0,0,0,0)},n._setReductions=function(t,e,n){const i=this;let o=e.l/Math.sin(n.l),r=Math.max(e.r-i.width,0)/Math.sin(n.r),a=-e.t/Math.cos(n.t),s=-Math.max(e.b-(i.height-i.paddingTop),0)/Math.cos(n.b);o=Qo(o),r=Qo(r),a=Qo(a),s=Qo(s),i.drawingArea=Math.min(Math.floor(t-(o+r)/2),Math.floor(t-(a+s)/2)),i.setCenterPoint(o,r,a,s)},n.setCenterPoint=function(t,e,n,i){const o=this,r=o.width-e-o.drawingArea,a=t+o.drawingArea,s=n+o.drawingArea,l=o.height-o.paddingTop-i-o.drawingArea;o.xCenter=Math.floor((a+r)/2+o.left),o.yCenter=Math.floor((s+l)/2+o.top+o.paddingTop)},n.getIndexAngle=function(t){const e=this.chart,n=mr/e.data.labels.length,i=e.options||{},o=i.startAngle||0;return B(t*n+L(o))},n.getDistanceFromCenterForValue=function(t){const e=this;if(u(t))return NaN;const n=e.drawingArea/(e.max-e.min);return e.options.reverse?(e.max-t)*n:(t-e.min)*n},n.getValueForDistanceFromCenter=function(t){if(u(t))return NaN;const e=this,n=t/(e.drawingArea/(e.max-e.min));return e.options.reverse?e.max-n:e.min+n},n.getPointPosition=function(t,e){const n=this,i=n.getIndexAngle(t)-_r;return{x:Math.cos(i)*e+n.xCenter,y:Math.sin(i)*e+n.yCenter,angle:i}},n.getPointPositionForValue=function(t,e){return this.getPointPosition(t,this.getDistanceFromCenterForValue(e))},n.getBasePosition=function(t){return this.getPointPositionForValue(t||0,this.getBaseValue())},n.drawGrid=function(){const t=this,e=t.ctx,n=t.options,i=n.gridLines,o=n.angleLines;let r,a,s;if(n.pointLabels.display&&Go(t),i.display&&t.ticks.forEach(function(e,n){0!==n&&(a=t.getDistanceFromCenterForValue(t.ticks[n].value),Zo(t,i,a,n))}),o.display){for(e.save(),r=t.chart.data.labels.length-1;r>=0;r--){const l=t.getContext(r),c=Dt([o.lineWidth,i.lineWidth],l,r),u=Dt([o.color,i.color],l,r);c&&u&&(e.lineWidth=c,e.strokeStyle=u,e.setLineDash&&(e.setLineDash(Dt([o.borderDash,i.borderDash,[]],l)),e.lineDashOffset=Dt([o.borderDashOffset,i.borderDashOffset,0],l,r)),a=t.getDistanceFromCenterForValue(n.ticks.reverse?t.min:t.max),s=t.getPointPosition(r,a),e.beginPath(),e.moveTo(t.xCenter,t.yCenter),e.lineTo(s.x,s.y),e.stroke())}e.restore()}},n.drawLabels=function(){const t=this,e=t.ctx,n=t.options,i=n.ticks;if(!i.display)return;const o=t.getIndexAngle(0);let r,a;e.save(),e.translate(t.xCenter,t.yCenter),e.rotate(o),e.textAlign="center",e.textBaseline="middle",t.ticks.forEach(function(o,s){if(0===s&&!n.reverse)return;const l=t.getContext(s),c=t._resolveTickFontOptions(s);e.font=c.string,r=t.getDistanceFromCenterForValue(t.ticks[s].value);const u=Dt([i.showLabelBackdrop],l,s);u&&(a=e.measureText(o.label).width,e.fillStyle=Dt([i.backdropColor],l,s),e.fillRect(-a/2-i.backdropPaddingX,-r-c.size/2-i.backdropPaddingY,a+2*i.backdropPaddingX,c.size+2*i.backdropPaddingY)),e.fillStyle=c.color,e.fillText(o.label,0,-r)}),e.restore()},n.drawTitle=function(){},e}(Ts);Ls.id="radialLinear",Ls.defaults={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,color:"rgba(0,0,0,0.1)",lineWidth:1,borderDash:[],borderDashOffset:0},gridLines:{circular:!1},ticks:{showLabelBackdrop:!0,backdropColor:"rgba(255,255,255,0.75)",backdropPaddingY:2,backdropPaddingX:2,callback:Wa.formatters.numeric},pointLabels:{display:!0,font:{size:10},callback:function(t){return t}}};const Cs=Number.MAX_SAFE_INTEGER||9007199254740991,Rs={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}},Fs=Object.keys(Rs),zs=function(t){function e(e){let n;return n=t.call(this,e)||this,n._cache={data:[],labels:[],all:[]},n._unit="day",n._majorUnit=void 0,n._offsets={},n._normalized=!1,n}i(e,t);const n=e.prototype;return n.init=function(e,n){const i=e.time||(e.time={}),o=this._adapter=new ns._date(e.adapters.date);v(i.displayFormats,o.formats()),t.prototype.init.call(this,e),this._normalized=n.normalized},n.parse=function(t,e){return void 0===t?NaN:tr(this,t)},n.invalidateCaches=function(){this._cache={data:[],labels:[],all:[]}},n.determineDataLimits=function(){function t(t){l||isNaN(t.min)||(a=Math.min(a,t.min)),c||isNaN(t.max)||(s=Math.max(s,t.max))}const e=this,n=e.options,i=e._adapter,o=n.time.unit||"day";let r=e.getUserBounds(),a=r.min,s=r.max,l=r.minDefined,c=r.maxDefined;l&&c||(t(e._getLabelBounds()),"ticks"===n.bounds&&"labels"===n.ticks.source||t(e.getMinMax(!1))),a=fr(a)&&!isNaN(a)?a:+i.startOf(Date.now(),o),s=fr(s)&&!isNaN(s)?s:+i.endOf(Date.now(),o)+1,e.min=Math.min(a,s),e.max=Math.max(a+1,s)},n._getLabelBounds=function(){const t=this.getLabelTimestamps();let e=Number.POSITIVE_INFINITY,n=Number.NEGATIVE_INFINITY;return t.length&&(e=t[0],n=t[t.length-1]),{min:e,max:n}},n.buildTicks=function(){const t=this,e=t.options,n=e.time,i=e.ticks,o="labels"===i.source?t.getLabelTimestamps():t._generate();"ticks"===e.bounds&&o.length&&(t.min=t._userMin||o[0],t.max=t._userMax||o[o.length-1]);const r=t.min,a=t.max,s=tt(o,r,a);return t._unit=n.unit||(i.autoSkip?er(n.minUnit,t.min,t.max,t._getLabelCapacity(r)):nr(t,s.length,n.minUnit,t.min,t.max)),t._majorUnit=i.major.enabled&&"year"!==t._unit?ir(t._unit):void 0,t.initOffsets(o),e.reverse&&s.reverse(),ar(t,s,t._majorUnit)},n.initOffsets=function(t){const e=this;let n,i,o=0,r=0;e.options.offset&&t.length&&(n=e.getDecimalForValue(t[0]),o=1===t.length?1-n:(e.getDecimalForValue(t[1])-n)/2,i=e.getDecimalForValue(t[t.length-1]),r=1===t.length?i:(i-e.getDecimalForValue(t[t.length-2]))/2),e._offsets={start:o,end:r,factor:1/(o+1+r)}},n._generate=function(){const t=this,e=t._adapter,n=t.min,i=t.max,o=t.options,r=o.time,a=r.unit||er(r.minUnit,n,i,t._getLabelCapacity(n)),s=d(r.stepSize,1),l="week"===a&&r.isoWeekday,c=A(l)||!0===l,u={};let h,f=n;if(c&&(f=+e.startOf(f,"isoWeek",l)),f=+e.startOf(f,c?"day":a),e.diff(i,n,a)>1e5*s)throw new Error(n+" and "+i+" are too far apart with stepSize of "+s+" "+a);const p="data"===o.ticks.source&&t.getDataTimestamps();for(h=f;h0?s:1},n.getDataTimestamps=function(){const t=this;let e,n,i=t._cache.data||[];if(i.length)return i;const o=t.getMatchingVisibleMetas();if(t._normalized&&o.length)return t._cache.data=o[0].controller.getAllParsedValues(t);for(e=0,n=o.length;en&&s0&&!u(e)?e/n._maxIndex:n.getDecimalForValue(t);return n.getPixelForDecimal((i.start+o)*i.factor)},n.getDecimalForValue=function(t){return sr(this._table,t)/this._maxIndex},n.getValueForPixel=function(t){const e=this,n=e._offsets,i=e.getDecimalForPixel(t)/n.factor-n.end;return sr(e._table,i*this._maxIndex,!0)},e}(zs);Is.id="timeseries",Is.defaults=zs.defaults;const Bs=Object.freeze({__proto__:null,CategoryScale:As,LinearScale:Os,LogarithmicScale:Es,RadialLinearScale:Ls,TimeScale:zs,TimeSeriesScale:Is});return qa.register(hs,Bs,ms,Ds),qa.helpers=n({},ts),qa._adapters=ns,qa.Animation=Da,qa.Animations=Oa,qa.animator=ur,qa.controllers=Ya.controllers.items,qa.DatasetController=za,qa.Element=Ia,qa.elements=ms,qa.Interaction=Er,qa.layouts=Rr,qa.platforms=ca, -qa.Scale=Na,qa.Ticks=Wa,n(qa,hs,Bs,ms,Ds,ca),qa.Chart=qa,"undefined"!=typeof window&&(window.Chart=qa),qa}();export{Chart}; \ No newline at end of file +/*! + * Chart.js v3.9.1 + * https://www.chartjs.org + * (c) 2022 Chart.js Contributors + * Released under the MIT License + */ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Chart=e()}(this,(function(){"use strict";function t(){}const e=function(){let t=0;return function(){return t++}}();function i(t){return null==t}function s(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 n(t){return null!==t&&"[object Object]"===Object.prototype.toString.call(t)}const o=t=>("number"==typeof t||t instanceof Number)&&isFinite(+t);function a(t,e){return o(t)?t:e}function r(t,e){return void 0===t?e:t}const l=(t,e)=>"string"==typeof t&&t.endsWith("%")?parseFloat(t)/100:t/e,h=(t,e)=>"string"==typeof t&&t.endsWith("%")?parseFloat(t)/100*e:+t;function c(t,e,i){if(t&&"function"==typeof t.call)return t.apply(i,e)}function d(t,e,i,o){let a,r,l;if(s(t))if(r=t.length,o)for(a=r-1;a>=0;a--)e.call(i,t[a],a);else for(a=0;at,x:t=>t.x,y:t=>t.y};function y(t,e){const i=_[e]||(_[e]=function(t){const e=v(t);return t=>{for(const i of e){if(""===i)break;t=t&&t[i]}return t}}(e));return i(t)}function v(t){const e=t.split("."),i=[];let s="";for(const t of e)s+=t,s.endsWith("\\")?s=s.slice(0,-1)+".":(i.push(s),s="");return i}function w(t){return t.charAt(0).toUpperCase()+t.slice(1)}const M=t=>void 0!==t,k=t=>"function"==typeof t,S=(t,e)=>{if(t.size!==e.size)return!1;for(const i of t)if(!e.has(i))return!1;return!0};function P(t){return"mouseup"===t.type||"click"===t.type||"contextmenu"===t.type}const D=Math.PI,O=2*D,C=O+D,A=Number.POSITIVE_INFINITY,T=D/180,L=D/2,E=D/4,R=2*D/3,I=Math.log10,z=Math.sign;function F(t){const e=Math.round(t);t=N(t,e,t/1e3)?e:t;const i=Math.pow(10,Math.floor(I(t))),s=t/i;return(s<=1?1:s<=2?2:s<=5?5:10)*i}function V(t){const e=[],i=Math.sqrt(t);let s;for(s=1;st-e)).pop(),e}function B(t){return!isNaN(parseFloat(t))&&isFinite(t)}function N(t,e,i){return Math.abs(t-e)=t}function j(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}function tt(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 et=(t,e,i,s)=>tt(t,i,s?s=>t[s][e]<=i:s=>t[s][e]tt(t,i,(s=>t[s][e]>=i));function st(t,e,i){let s=0,n=t.length;for(;ss&&t[n-1]>i;)n--;return s>0||n{const i="_onData"+w(e),s=t[e];Object.defineProperty(t,e,{configurable:!0,enumerable:!1,value(...e){const n=s.apply(this,e);return t._chartjs.listeners.forEach((t=>{"function"==typeof t[i]&&t[i](...e)})),n}})})))}function at(t,e){const i=t._chartjs;if(!i)return;const s=i.listeners,n=s.indexOf(e);-1!==n&&s.splice(n,1),s.length>0||(nt.forEach((e=>{delete t[e]})),delete t._chartjs)}function rt(t){const e=new Set;let i,s;for(i=0,s=t.length;iArray.prototype.slice.call(t));let n=!1,o=[];return function(...i){o=s(i),n||(n=!0,lt.call(window,(()=>{n=!1,t.apply(e,o)})))}}function ct(t,e){let i;return function(...s){return e?(clearTimeout(i),i=setTimeout(t,e,s)):t.apply(this,s),e}}const dt=t=>"start"===t?"left":"end"===t?"right":"center",ut=(t,e,i)=>"start"===t?e:"end"===t?i:(e+i)/2,ft=(t,e,i,s)=>t===(s?"left":"right")?i:"center"===t?(e+i)/2:e;function gt(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=Z(Math.min(et(r,a.axis,h).lo,i?s:et(e,l,a.getPixelForValue(h)).lo),0,s-1)),o=u?Z(Math.max(et(r,a.axis,c,!0).hi+1,i?0:et(e,l,a.getPixelForValue(c),!0).hi+1),n,s)-n:s-n}return{start:n,count:o}}function pt(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}var mt=new class{constructor(){this._request=null,this._charts=new Map,this._running=!1,this._lastDate=void 0}_notify(t,e,i,s){const n=e.listeners[s],o=e.duration;n.forEach((s=>s({chart:t,initial:e.initial,numSteps:o,currentStep:Math.min(i-e.start,o)})))}_refresh(){this._request||(this._running=!0,this._request=lt.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)}}; +/*! + * @kurkle/color v0.2.1 + * https://github.com/kurkle/color#readme + * (c) 2022 Jukka Kurkela + * Released under the MIT License + */function bt(t){return t+.5|0}const xt=(t,e,i)=>Math.max(Math.min(t,i),e);function _t(t){return xt(bt(2.55*t),0,255)}function yt(t){return xt(bt(255*t),0,255)}function vt(t){return xt(bt(t/2.55)/100,0,1)}function wt(t){return xt(bt(100*t),0,100)}const Mt={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},kt=[..."0123456789ABCDEF"],St=t=>kt[15&t],Pt=t=>kt[(240&t)>>4]+kt[15&t],Dt=t=>(240&t)>>4==(15&t);function Ot(t){var e=(t=>Dt(t.r)&&Dt(t.g)&&Dt(t.b)&&Dt(t.a))(t)?St:Pt;return t?"#"+e(t.r)+e(t.g)+e(t.b)+((t,e)=>t<255?e(t):"")(t.a,e):void 0}const Ct=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function At(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 Tt(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 Lt(t,e,i){const s=At(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 Et(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}(),Nt.transparent=[0,0,0,0]);const e=Nt[t.toLowerCase()];return e&&{r:e[0],g:e[1],b:e[2],a:4===e.length?e[3]:255}}const jt=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;const Ht=t=>t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055,$t=t=>t<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4);function Yt(t,e,i){if(t){let s=Et(t);s[e]=Math.max(0,Math.min(s[e]+s[e]*i,0===e?360:1)),s=It(s),t.r=s[0],t.g=s[1],t.b=s[2]}}function Ut(t,e){return t?Object.assign(e||{},t):t}function Xt(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=yt(t[3]))):(e=Ut(t,{r:0,g:0,b:0,a:1})).a=yt(e.a),e}function qt(t){return"r"===t.charAt(0)?function(t){const e=jt.exec(t);let i,s,n,o=255;if(e){if(e[7]!==i){const t=+e[7];o=e[8]?_t(t):xt(255*t,0,255)}return i=+e[1],s=+e[3],n=+e[5],i=255&(e[2]?_t(i):xt(i,0,255)),s=255&(e[4]?_t(s):xt(s,0,255)),n=255&(e[6]?_t(n):xt(n,0,255)),{r:i,g:s,b:n,a:o}}}(t):Ft(t)}class Kt{constructor(t){if(t instanceof Kt)return t;const e=typeof t;let i;var s,n,o;"object"===e?i=Xt(t):"string"===e&&(o=(s=t).length,"#"===s[0]&&(4===o||5===o?n={r:255&17*Mt[s[1]],g:255&17*Mt[s[2]],b:255&17*Mt[s[3]],a:5===o?17*Mt[s[4]]:255}:7!==o&&9!==o||(n={r:Mt[s[1]]<<4|Mt[s[2]],g:Mt[s[3]]<<4|Mt[s[4]],b:Mt[s[5]]<<4|Mt[s[6]],a:9===o?Mt[s[7]]<<4|Mt[s[8]]:255})),i=n||Wt(t)||qt(t)),this._rgb=i,this._valid=!!i}get valid(){return this._valid}get rgb(){var t=Ut(this._rgb);return t&&(t.a=vt(t.a)),t}set rgb(t){this._rgb=Xt(t)}rgbString(){return this._valid?(t=this._rgb)&&(t.a<255?`rgba(${t.r}, ${t.g}, ${t.b}, ${vt(t.a)})`:`rgb(${t.r}, ${t.g}, ${t.b})`):void 0;var t}hexString(){return this._valid?Ot(this._rgb):void 0}hslString(){return this._valid?function(t){if(!t)return;const e=Et(t),i=e[0],s=wt(e[1]),n=wt(e[2]);return t.a<255?`hsla(${i}, ${s}%, ${n}%, ${vt(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=$t(vt(t.r)),n=$t(vt(t.g)),o=$t(vt(t.b));return{r:yt(Ht(s+i*($t(vt(e.r))-s))),g:yt(Ht(n+i*($t(vt(e.g))-n))),b:yt(Ht(o+i*($t(vt(e.b))-o))),a:t.a+i*(e.a-t.a)}}(this._rgb,t._rgb,e)),this}clone(){return new Kt(this.rgb)}alpha(t){return this._rgb.a=yt(t),this}clearer(t){return this._rgb.a*=1-t,this}greyscale(){const t=this._rgb,e=bt(.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 Yt(this._rgb,2,t),this}darken(t){return Yt(this._rgb,2,-t),this}saturate(t){return Yt(this._rgb,1,t),this}desaturate(t){return Yt(this._rgb,1,-t),this}rotate(t){return function(t,e){var i=Et(t);i[0]=zt(i[0]+e),i=It(i),t.r=i[0],t.g=i[1],t.b=i[2]}(this._rgb,t),this}}function Gt(t){return new Kt(t)}function Zt(t){if(t&&"object"==typeof t){const e=t.toString();return"[object CanvasPattern]"===e||"[object CanvasGradient]"===e}return!1}function Jt(t){return Zt(t)?t:Gt(t)}function Qt(t){return Zt(t)?t:Gt(t).saturate(.5).darken(.1).hexString()}const te=Object.create(null),ee=Object.create(null);function ie(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)=>Qt(e.backgroundColor),this.hoverBorderColor=(t,e)=>Qt(e.borderColor),this.hoverColor=(t,e)=>Qt(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 se(this,t,e)}get(t){return ie(this,t)}describe(t,e){return se(ee,t,e)}override(t,e){return se(te,t,e)}route(t,e,i,s){const o=ie(this,t),a=ie(this,i),l="_"+e;Object.defineProperties(o,{[l]:{value:o[e],writable:!0},[e]:{enumerable:!0,get(){const t=this[l],e=a[s];return n(t)?Object.assign({},e,t):r(t,e)},set(t){this[l]=t}}})}}({_scriptable:t=>!t.startsWith("on"),_indexable:t=>"events"!==t,hover:{_fallback:"interaction"},interaction:{_scriptable:!1,_indexable:!1}});function oe(){return"undefined"!=typeof window&&"undefined"!=typeof document}function ae(t){let e=t.parentNode;return e&&"[object ShadowRoot]"===e.toString()&&(e=e.host),e}function re(t,e,i){let s;return"string"==typeof t?(s=parseInt(t,10),-1!==t.indexOf("%")&&(s=s/100*e.parentNode[i])):s=t,s}const le=t=>window.getComputedStyle(t,null);function he(t,e){return le(t).getPropertyValue(e)}const ce=["top","right","bottom","left"];function de(t,e,i){const s={};i=i?"-"+i:"";for(let n=0;n<4;n++){const o=ce[n];s[o]=parseFloat(t[e+"-"+o+i])||0}return s.width=s.left+s.right,s.height=s.top+s.bottom,s}function ue(t,e){if("native"in t)return t;const{canvas:i,currentDevicePixelRatio:s}=e,n=le(i),o="border-box"===n.boxSizing,a=de(n,"padding"),r=de(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 fe=t=>Math.round(10*t)/10;function ge(t,e,i,s){const n=le(t),o=de(n,"margin"),a=re(n.maxWidth,t,"clientWidth")||A,r=re(n.maxHeight,t,"clientHeight")||A,l=function(t,e,i){let s,n;if(void 0===e||void 0===i){const o=ae(t);if(o){const t=o.getBoundingClientRect(),a=le(o),r=de(a,"border","width"),l=de(a,"padding");e=t.width-l.width-r.width,i=t.height-l.height-r.height,s=re(a.maxWidth,o,"clientWidth"),n=re(a.maxHeight,o,"clientHeight")}else e=t.clientWidth,i=t.clientHeight}return{width:e,height:i,maxWidth:s||A,maxHeight:n||A}}(t,e,i);let{width:h,height:c}=l;if("content-box"===n.boxSizing){const t=de(n,"border","width"),e=de(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=fe(Math.min(h,a,l.maxWidth)),c=fe(Math.min(c,r,l.maxHeight)),h&&!c&&(c=fe(h/2)),{width:h,height:c}}function pe(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 me=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 be(t,e){const i=he(t,e),s=i&&i.match(/^(\d+)(\.\d+)?px$/);return s?+s[1]:void 0}function xe(t){return!t||i(t.size)||i(t.family)?null:(t.style?t.style+" ":"")+(t.weight?t.weight+" ":"")+t.size+"px "+t.family}function _e(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 ye(t,e,i,n){let o=(n=n||{}).data=n.data||{},a=n.garbageCollect=n.garbageCollect||[];n.font!==e&&(o=n.data={},a=n.garbageCollect=[],n.font=e),t.save(),t.font=e;let r=0;const l=i.length;let h,c,d,u,f;for(h=0;hi.length){for(h=0;h0&&t.stroke()}}function Se(t,e,i){return i=i||.5,!e||t&&t.x>e.left-i&&t.xe.top-i&&t.y0&&""!==r.strokeColor;let c,d;for(t.save(),t.font=a.string,function(t,e){e.translation&&t.translate(e.translation[0],e.translation[1]);i(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,r),c=0;ct[0])){M(s)||(s=$e("_fallback",t));const o={[Symbol.toStringTag]:"Object",_cacheable:!0,_scopes:t,_rootScopes:i,_fallback:s,_getTarget:n,override:n=>Ee([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)=>Ve(i,s,(()=>function(t,e,i,s){let n;for(const o of e)if(n=$e(ze(o,t),i),M(n))return Fe(t,n)?je(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)=>Ye(t).includes(e),ownKeys:t=>Ye(t),set(t,e,i){const s=t._storage||(t._storage=n());return t[e]=s[e]=i,delete t._keys,!0}})}function Re(t,e,i,o){const a={_cacheable:!1,_proxy:t,_context:e,_subProxy:i,_stack:new Set,_descriptors:Ie(t,o),setContext:e=>Re(t,e,i,o),override:s=>Re(t.override(s),e,i,o)};return new Proxy(a,{deleteProperty:(e,i)=>(delete e[i],delete t[i],!0),get:(t,e,i)=>Ve(t,e,(()=>function(t,e,i){const{_proxy:o,_context:a,_subProxy:r,_descriptors:l}=t;let h=o[e];k(h)&&l.isScriptable(e)&&(h=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),Fe(t,e)&&(e=je(n._scopes,n,t,e));return e}(e,h,t,i));s(h)&&h.length&&(h=function(t,e,i,s){const{_proxy:o,_context:a,_subProxy:r,_descriptors:l}=i;if(M(a.index)&&s(t))e=e[a.index%e.length];else if(n(e[0])){const i=e,s=o._scopes.filter((t=>t!==i));e=[];for(const n of i){const i=je(s,o,t,n);e.push(Re(i,a,r&&r[t],l))}}return e}(e,h,t,l.isIndexable));Fe(e,h)&&(h=Re(h,a,r&&r[e],l));return h}(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 Ie(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:k(i)?i:()=>i,isIndexable:k(s)?s:()=>s}}const ze=(t,e)=>t?t+w(e):e,Fe=(t,e)=>n(e)&&"adapters"!==t&&(null===Object.getPrototypeOf(e)||e.constructor===Object);function Ve(t,e,i){if(Object.prototype.hasOwnProperty.call(t,e))return t[e];const s=i();return t[e]=s,s}function Be(t,e,i){return k(t)?t(e,i):t}const Ne=(t,e)=>!0===t?e:"string"==typeof t?y(e,t):void 0;function We(t,e,i,s,n){for(const o of e){const e=Ne(i,o);if(e){t.add(e);const o=Be(e._fallback,i,n);if(M(o)&&o!==i&&o!==s)return o}else if(!1===e&&M(s)&&i!==s)return null}return!1}function je(t,e,i,o){const a=e._rootScopes,r=Be(e._fallback,i,o),l=[...t,...a],h=new Set;h.add(o);let c=He(h,l,i,r||i,o);return null!==c&&((!M(r)||r===i||(c=He(h,l,r,c,o),null!==c))&&Ee(Array.from(h),[""],a,r,(()=>function(t,e,i){const o=t._getTarget();e in o||(o[e]={});const a=o[e];if(s(a)&&n(i))return i;return a}(e,i,o))))}function He(t,e,i,s,n){for(;i;)i=We(t,e,i,s,n);return i}function $e(t,e){for(const i of e){if(!i)continue;const e=i[t];if(M(e))return e}}function Ye(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 Ue(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 Ge(t,e,i,s){const n=t.skip?e:t,o=e,a=i.skip?e:i,r=X(o,n),l=X(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 Ze(t,e="x"){const i=Ke(e),s=t.length,n=Array(s).fill(0),o=Array(s);let a,r,l,h=qe(t,0);for(a=0;a!t.skip))),"monotone"===e.cubicInterpolationMode)Ze(t,n);else{let i=s?t[t.length-1]:t[0];for(o=0,a=t.length;o0===t||1===t,ei=(t,e,i)=>-Math.pow(2,10*(t-=1))*Math.sin((t-e)*O/i),ii=(t,e,i)=>Math.pow(2,-10*t)*Math.sin((t-e)*O/i)+1,si={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*L),easeOutSine:t=>Math.sin(t*L),easeInOutSine:t=>-.5*(Math.cos(D*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=>ti(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=>ti(t)?t:ei(t,.075,.3),easeOutElastic:t=>ti(t)?t:ii(t,.075,.3),easeInOutElastic(t){const e=.1125;return ti(t)?t:t<.5?.5*ei(2*t,e,.45):.5+.5*ii(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-si.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*si.easeInBounce(2*t):.5*si.easeOutBounce(2*t-1)+.5};function ni(t,e,i,s){return{x:t.x+i*(e.x-t.x),y:t.y+i*(e.y-t.y)}}function oi(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 ai(t,e,i,s){const n={x:t.cp2x,y:t.cp2y},o={x:e.cp1x,y:e.cp1y},a=ni(t,n,i),r=ni(n,o,i),l=ni(o,e,i),h=ni(a,r,i),c=ni(r,l,i);return ni(h,c,i)}const ri=new Map;function li(t,e,i){return function(t,e){e=e||{};const i=t+JSON.stringify(e);let s=ri.get(i);return s||(s=new Intl.NumberFormat(t,e),ri.set(i,s)),s}(e,i).format(t)}const hi=new RegExp(/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/),ci=new RegExp(/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/);function di(t,e){const i=(""+t).match(hi);if(!i||"normal"===i[1])return 1.2*e;switch(t=+i[2],i[3]){case"px":return t;case"%":t/=100}return e*t}function ui(t,e){const i={},s=n(e),o=s?Object.keys(e):e,a=n(t)?s?i=>r(t[i],t[e[i]]):e=>t[e]:()=>t;for(const t of o)i[t]=+a(t)||0;return i}function fi(t){return ui(t,{top:"y",right:"x",bottom:"y",left:"x"})}function gi(t){return ui(t,["topLeft","topRight","bottomLeft","bottomRight"])}function pi(t){const e=fi(t);return e.width=e.left+e.right,e.height=e.top+e.bottom,e}function mi(t,e){t=t||{},e=e||ne.font;let i=r(t.size,e.size);"string"==typeof i&&(i=parseInt(i,10));let s=r(t.style,e.style);s&&!(""+s).match(ci)&&(console.warn('Invalid font style specified: "'+s+'"'),s="");const n={family:r(t.family,e.family),lineHeight:di(r(t.lineHeight,e.lineHeight),i),size:i,style:s,weight:r(t.weight,e.weight),string:""};return n.string=xe(n),n}function bi(t,e,i,n){let o,a,r,l=!0;for(o=0,a=t.length;oi&&0===t?0:t+e;return{min:a(s,-Math.abs(o)),max:a(n,o)}}function _i(t,e){return Object.assign(Object.create(t),e)}function yi(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 vi(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 wi(t,e){void 0!==e&&(delete t.prevTextDirection,t.canvas.style.setProperty("direction",e[0],e[1]))}function Mi(t){return"angle"===t?{between:G,compare:q,normalize:K}:{between:Q,compare:(t,e)=>t-e,normalize:t=>t}}function ki({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 Si(t,e,i){if(!i)return[t];const{property:s,start:n,end:o}=i,a=e.length,{compare:r,between:l,normalize:h}=Mi(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}=Mi(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;hx||l(n,b,p)&&0!==r(n,b),v=()=>!x||0===r(o,p)||l(o,b,p);for(let t=c,i=c;t<=d;++t)m=e[t%a],m.skip||(p=h(m[s]),p!==b&&(x=l(p,n,o),null===_&&y()&&(_=0===r(p,n)?t:i),null!==_&&v()&&(g.push(ki({start:_,end:t,loop:u,count:a,style:f})),_=null),i=t,b=p));return null!==_&&g.push(ki({start:_,end:d,loop:u,count:a,style:f})),g}function Pi(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 Oi(t,[{start:a,end:r,loop:o}],i,e);return Oi(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,r{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 Vi={evaluateInteractionItems:Ei,modes:{index(t,e,i,s){const n=ue(e,t),o=i.axis||"x",a=i.includeInvisible||!1,r=i.intersect?Ri(t,n,o,s,a):zi(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=ue(e,t),o=i.axis||"xy",a=i.includeInvisible||!1;let r=i.intersect?Ri(t,n,o,s,a):zi(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;tRi(t,ue(e,t),i.axis||"xy",s,i.includeInvisible||!1),nearest(t,e,i,s){const n=ue(e,t),o=i.axis||"xy",a=i.includeInvisible||!1;return zi(t,n,o,i.intersect,s,a)},x:(t,e,i,s)=>Fi(t,ue(e,t),"x",i.intersect,s),y:(t,e,i,s)=>Fi(t,ue(e,t),"y",i.intersect,s)}};const Bi=["left","top","right","bottom"];function Ni(t,e){return t.filter((t=>t.pos===e))}function Wi(t,e){return t.filter((t=>-1===Bi.indexOf(t.pos)&&t.box.axis===e))}function ji(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 Hi(t,e){const i=function(t){const e={};for(const i of t){const{stack:t,pos:s,stackWeight:n}=i;if(!t||!Bi.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 qi(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=ji(Ni(e,"left"),!0),n=ji(Ni(e,"right")),o=ji(Ni(e,"top"),!0),a=ji(Ni(e,"bottom")),r=Wi(e,"x"),l=Wi(e,"y");return{fullSize:i,leftAndTop:s.concat(o),rightAndBottom:n.concat(l).concat(a).concat(r),chartArea:Ni(e,"chartArea"),vertical:s.concat(n).concat(l),horizontal:o.concat(a).concat(r)}}(t.boxes),l=r.vertical,h=r.horizontal;d(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,u=Object.freeze({outerWidth:e,outerHeight:i,padding:n,availableWidth:o,availableHeight:a,vBoxMaxWidth:o/2/c,hBoxMaxHeight:a/2}),f=Object.assign({},n);Yi(f,pi(s));const g=Object.assign({maxPadding:f,w:o,h:a,x:n.left,y:n.top},n),p=Hi(l.concat(h),u);qi(r.fullSize,g,u,p),qi(l,g,u,p),qi(h,g,u,p)&&qi(l,g,u,p),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")}(g),Gi(r.leftAndTop,g,u,p),g.x+=g.w,g.y+=g.h,Gi(r.rightAndBottom,g,u,p),t.chartArea={left:g.left,top:g.top,right:g.left+g.w,bottom:g.top+g.h,height:g.h,width:g.w},d(r.chartArea,(e=>{const i=e.box;Object.assign(i,t.chartArea),i.update(g.w,g.h,{left:0,top:0,right:0,bottom:0})}))}};class Ji{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 Qi extends Ji{acquireContext(t){return t&&t.getContext&&t.getContext("2d")||null}updateConfig(t){t.options.animation=!1}}const ts={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"},es=t=>null===t||""===t;const is=!!me&&{passive:!0};function ss(t,e,i){t.canvas.removeEventListener(e,i,is)}function ns(t,e){for(const i of t)if(i===e||i.contains(e))return!0}function os(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||ns(i.addedNodes,s),e=e&&!ns(i.removedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}function as(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||ns(i.removedNodes,s),e=e&&!ns(i.addedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}const rs=new Map;let ls=0;function hs(){const t=window.devicePixelRatio;t!==ls&&(ls=t,rs.forEach(((e,i)=>{i.currentDevicePixelRatio!==t&&e()})))}function cs(t,e,i){const s=t.canvas,n=s&&ae(s);if(!n)return;const o=ht(((t,e)=>{const s=n.clientWidth;i(t,e),s{const e=t[0],i=e.contentRect.width,s=e.contentRect.height;0===i&&0===s||o(i,s)}));return a.observe(n),function(t,e){rs.size||window.addEventListener("resize",hs),rs.set(t,e)}(t,o),a}function ds(t,e,i){i&&i.disconnect(),"resize"===e&&function(t){rs.delete(t),rs.size||window.removeEventListener("resize",hs)}(t)}function us(t,e,i){const s=t.canvas,n=ht((e=>{null!==t.ctx&&i(function(t,e){const i=ts[t.type]||t.type,{x:s,y:n}=ue(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,is)}(s,e,n),n}class fs extends Ji{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",es(n)){const e=be(t,"width");void 0!==e&&(t.width=e)}if(es(s))if(""===t.style.height)t.height=t.width/(e||2);else{const e=be(t,"height");void 0!==e&&(t.height=e)}}(t,e),i):null}releaseContext(t){const e=t.canvas;if(!e.$chartjs)return!1;const s=e.$chartjs.initial;["height","width"].forEach((t=>{const n=s[t];i(n)?e.removeAttribute(t):e.setAttribute(t,n)}));const n=s.style||{};return Object.keys(n).forEach((t=>{e.style[t]=n[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:os,detach:as,resize:cs}[e]||us;s[e]=n(t,e,i)}removeEventListener(t,e){const i=t.$proxies||(t.$proxies={}),s=i[e];if(!s)return;({attach:ds,detach:ds,resize:ds}[e]||ss)(t,e,s),i[e]=void 0}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(t,e,i,s){return ge(t,e,i,s)}isAttached(t){const e=ae(t);return!(!e||!e.isConnected)}}function gs(t){return!oe()||"undefined"!=typeof OffscreenCanvas&&t instanceof OffscreenCanvas?Qi:fs}var ps=Object.freeze({__proto__:null,_detectPlatform:gs,BasePlatform:Ji,BasicPlatform:Qi,DomPlatform:fs});const ms="transparent",bs={boolean:(t,e,i)=>i>.5?e:t,color(t,e,i){const s=Jt(t||ms),n=s.valid&&Jt(e||ms);return n&&n.valid?n.mix(s,i).hexString():e},number:(t,e,i)=>t+(e-t)*i};class xs{constructor(t,e,i,s){const n=e[i];s=bi([t.to,s,n,t.from]);const o=bi([t.from,n,s]);this._active=!0,this._fn=t.fn||bs[t.type||typeof o],this._easing=si[t.easing]||si.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=bi([t.to,e,s,t.from]),this._from=bi([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}),ne.set("animations",{colors:{type:"color",properties:["color","borderColor","backgroundColor"]},numbers:{type:"number",properties:["x","y","borderWidth","radius","tension"]}}),ne.describe("animations",{_fallback:"animation"}),ne.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 ys{constructor(t,e){this._chart=t,this._properties=new Map,this.configure(e)}configure(t){if(!n(t))return;const e=this._properties;Object.getOwnPropertyNames(t).forEach((i=>{const o=t[i];if(!n(o))return;const a={};for(const t of _s)a[t]=o[t];(s(o.properties)&&o.properties||[i]).forEach((t=>{t!==i&&e.has(t)||e.set(t,a)}))}))}_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 xs(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?(mt.add(this._chart,i),!0):void 0}}function vs(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 ws(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 Ds(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 Cs(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 As=t=>"reset"===t||"none"===t,Ts=(t,e)=>e?t:Object.assign({},t);class Ls{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=ks(t.vScale,t),this.addElements()}updateIndex(t){this.index!==t&&Cs(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=r(i.xAxisID,Os(t,"x")),o=e.yAxisID=r(i.yAxisID,Os(t,"y")),a=e.rAxisID=r(i.rAxisID,Os(t,"r")),l=e.indexAxis,h=e.iAxisID=s(l,n,o,a),c=e.vAxisID=s(l,o,n,a);e.xScale=this.getScaleForId(n),e.yScale=this.getScaleForId(o),e.rScale=this.getScaleForId(a),e.iScale=this.getScaleForId(h),e.vScale=this.getScaleForId(c)}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&&at(this._data,this),t._stacked&&Cs(t)}_dataCheck(){const t=this.getDataset(),e=t.data||(t.data=[]),i=this._data;if(n(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;s0&&i._parsed[t-1];if(!1===this._parsing)i._parsed=o,i._sorted=!0,d=o;else{d=s(o[t])?this.parseArrayData(i,o,t,e):n(o[t])?this.parseObjectData(i,o,t,e):this.parsePrimitiveData(i,o,t,e);const a=()=>null===c[l]||f&&c[l]t&&!e.hidden&&e._stacked&&{keys:ws(i,!0),values:null})(e,i,this.chart),h={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY},{min:c,max:d}=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}}(r);let u,f;function g(){f=s[u];const e=f[r.axis];return!o(f[t.axis])||c>e||d=0;--u)if(!g()){this.updateRangeFromParsed(h,t,f,l);break}return h}getAllParsedValues(t){const e=this._cachedMeta._parsed,i=[];let s,n,a;for(s=0,n=e.length;s=0&&tthis.getContext(i,s)),c);return f.$shared&&(f.$shared=r,n[o]=Object.freeze(Ts(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 ys(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||As(t)||this.chart._animationsDisabled}_getSharedOptions(t,e){const i=this.resolveDataElementOptions(t,e),s=this._sharedOptions,n=this.getSharedOptions(i),o=this.includeOptions(e,n)||n!==s;return this.updateSharedOptions(n,e,i),{sharedOptions:n,includeOptions:o}}updateElement(t,e,i,s){As(s)?Object.assign(t,i):this._resolveAnimations(e,s).update(t,i)}updateSharedOptions(t,e,i){t&&!As(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;a{s[t]=i[t]&&i[t].active()?i[t]._to:this[t]})),s}}Es.defaults={},Es.defaultRoutes=void 0;const Rs={values:t=>s(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=I(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),li(t,s,l)},logarithmic(t,e,i){if(0===t)return"0";const s=t/Math.pow(10,Math.floor(I(t)));return 1===s||2===s||5===s?Rs.numeric.call(this,t,e,i):""}};var Is={formatters:Rs};function zs(t,e){const s=t.options.ticks,n=s.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),o=s.major.enabled?function(t){const e=[];let i,s;for(i=0,s=t.length;in)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)}(o,e,n);if(a>0){let t,s;const n=a>1?Math.round((l-r)/(a-1)):null;for(Fs(e,h,c,i(n)?0:r-n,r),t=0,s=a-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:Is.formatters.values,minor:{},major:{},align:"center",crossAlign:"near",showLabelBackdrop:!1,backdropColor:"rgba(255, 255, 255, 0.75)",backdropPadding:2}}),ne.route("scale.ticks","color","","color"),ne.route("scale.grid","color","","borderColor"),ne.route("scale.grid","borderColor","","borderColor"),ne.route("scale.title","color","","color"),ne.describe("scale",{_fallback:!1,_scriptable:t=>!t.startsWith("before")&&!t.startsWith("after")&&"callback"!==t&&"parser"!==t,_indexable:t=>"borderDash"!==t&&"tickBorderDash"!==t}),ne.describe("scales",{_fallback:"scale"}),ne.describe("scale.ticks",{_scriptable:t=>"backdropPadding"!==t&&"callback"!==t,_indexable:t=>"backdropPadding"!==t});const Vs=(t,e,i)=>"top"===e||"left"===e?t[e]+i:t[e]-i;function Bs(t,e){const i=[],s=t.length/e,n=t.length;let o=0;for(;oa+r)))return h}function Ws(t){return t.drawTicks?t.tickLength:0}function js(t,e){if(!t.display)return 0;const i=mi(t.font,e),n=pi(t.padding);return(s(t.text)?t.text.length:1)*i.lineHeight+n.height}function Hs(t,e,i){let s=dt(t);return(i&&"right"!==e||!i&&"right"===e)&&(s=(t=>"left"===t?"right":"right"===t?"left":t)(s)),s}class $s extends Es{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=a(t,Number.POSITIVE_INFINITY),e=a(e,Number.NEGATIVE_INFINITY),i=a(i,Number.POSITIVE_INFINITY),s=a(s,Number.NEGATIVE_INFINITY),{min:a(t,i),max:a(e,s),minDefined:o(t),maxDefined:o(e)}}getMinMax(t){let e,{min:i,max:s,minDefined:n,maxDefined:o}=this.getUserBounds();if(n&&o)return{min:i,max:s};const r=this.getMatchingVisibleMetas();for(let a=0,l=r.length;as?s:i,s=n&&i>s?i:s,{min:a(i,a(s,i)),max:a(s,a(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(){c(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=xi(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=Z(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-Ws(t.grid)-e.padding-js(t.title,this.chart.options.font),r=Math.sqrt(c*c+d*d),l=$(Math.min(Math.asin(Z((h.highest.height+6)/o,-1,1)),Math.asin(Z(a/r,-1,1))-Math.asin(Z(d/r,-1,1)))),l=Math.max(s,Math.min(n,l))),this.labelRotation=l}afterCalculateLabelRotation(){c(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){c(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=js(s,e.options.font);if(a?(t.width=this.maxWidth,t.height=Ws(n)+o):(t.height=this.maxHeight,t.width=Ws(n)+o),i.display&&this.ticks.length){const{first:e,last:s,widest:n,highest:o}=this._getLabelSizes(),r=2*i.padding,l=H(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(){c(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,s;for(this.beforeTickToLabelConversion(),this.generateTickLabels(t),e=0,s=t.length;e{const i=t.gc,s=i.length/2;let n;if(s>e){for(n=0;n({width:a[t]||0,height:r[t]||0});return{first:k(0),last:k(e-1),widest:k(w),highest:k(M),widths:a,heights:r}}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 J(this._alignToPixels?ve(this.chart,e,0):e)}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:o,position:a}=s,l=o.offset,h=this.isHorizontal(),c=this.ticks.length+(l?1:0),d=Ws(o),u=[],f=o.setContext(this.getContext()),g=f.drawBorder?f.borderWidth:0,p=g/2,m=function(t){return ve(i,t,g)};let b,x,_,y,v,w,M,k,S,P,D,O;if("top"===a)b=m(this.bottom),w=this.bottom-d,k=b-p,P=m(t.top)+p,O=t.bottom;else if("bottom"===a)b=m(this.top),P=t.top,O=m(t.bottom)-p,w=b+p,k=this.top+d;else if("left"===a)b=m(this.right),v=this.right-d,M=b-p,S=m(t.left)+p,D=t.right;else if("right"===a)b=m(this.left),S=t.left,D=m(t.right)-p,v=b+p,M=this.left+d;else if("x"===e){if("center"===a)b=m((t.top+t.bottom)/2+.5);else if(n(a)){const t=Object.keys(a)[0],e=a[t];b=m(this.chart.scales[t].getPixelForValue(e))}P=t.top,O=t.bottom,w=b+p,k=w+d}else if("y"===e){if("center"===a)b=m((t.left+t.right)/2);else if(n(a)){const t=Object.keys(a)[0],e=a[t];b=m(this.chart.scales[t].getPixelForValue(e))}v=b-p,M=v-d,S=t.left,D=t.right}const C=r(s.ticks.maxTicksLimit,c),A=Math.max(1,Math.ceil(c/C));for(x=0;xe.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(".");ne.route(o,n,l,r)}))}(e,t.defaultRoutes);t.descriptors&&ne.describe(e,t.descriptors)}(t,o,i),this.override&&ne.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 ne[s]&&(delete ne[s][i],this.override&&delete te[i])}}var Us=new class{constructor(){this.controllers=new Ys(Ls,"datasets",!0),this.elements=new Ys(Es,"elements"),this.plugins=new Ys(Object,"plugins"),this.scales=new Ys($s,"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):d(e,(e=>{const s=i||this._getRegistryForType(e);this._exec(t,s,e)}))}))}_exec(t,e,i){const s=w(t);c(i["before"+s],[],i),e[t](i),c(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 qs(t,e){return e||!1!==t?!0===t?{}:t:null}function Ks(t,{plugin:e,local:i},s,n){const o=t.pluginScopeKeys(e),a=t.getOptionScopes(s,o);return i&&e.defaults&&a.push(e.defaults),t.createResolver(a,n,[""],{scriptable:!1,indexable:!1,allKeys:!0})}function Gs(t,e){const i=ne.datasets[t]||{};return((e.datasets||{})[t]||{}).indexAxis||e.indexAxis||i.indexAxis||"x"}function Zs(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 Js(t){const e=t.options||(t.options={});e.plugins=r(e.plugins,{}),e.scales=function(t,e){const i=te[t.type]||{scales:{}},s=e.scales||{},o=Gs(t.type,e),a=Object.create(null),r=Object.create(null);return Object.keys(s).forEach((t=>{const e=s[t];if(!n(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 l=Zs(t,e),h=function(t,e){return t===e?"_index_":"_value_"}(l,o),c=i.scales||{};a[l]=a[l]||t,r[t]=b(Object.create(null),[{axis:l},e,c[l],c[h]])})),t.data.datasets.forEach((i=>{const n=i.type||t.type,o=i.indexAxis||Gs(n,e),l=(te[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,o),n=i[e+"AxisID"]||a[e]||e;r[n]=r[n]||Object.create(null),b(r[n],[{axis:e},s[n],l[t]])}))})),Object.keys(r).forEach((t=>{const e=r[t];b(e,[ne.scales[e.type],ne.scale])})),r}(t,e)}function Qs(t){return(t=t||{}).datasets=t.datasets||[],t.labels=t.labels||[],t}const tn=new Map,en=new Set;function sn(t,e){let i=tn.get(t);return i||(i=e(),tn.set(t,i),en.add(i)),i}const nn=(t,e,i)=>{const s=y(e,i);void 0!==s&&t.add(s)};class on{constructor(t){this._config=function(t){return(t=t||{}).data=Qs(t.data),Js(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=Qs(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(),Js(t)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(t){return sn(t,(()=>[[`datasets.${t}`,""]]))}datasetAnimationScopeKeys(t,e){return sn(`${t}.transition.${e}`,(()=>[[`datasets.${t}.transitions.${e}`,`transitions.${e}`],[`datasets.${t}`,""]]))}datasetElementScopeKeys(t,e){return sn(`${t}-${e}`,(()=>[[`datasets.${t}.elements.${e}`,`datasets.${t}`,`elements.${e}`,""]]))}pluginScopeKeys(t){const e=t.id;return sn(`${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=>nn(r,t,e)))),e.forEach((t=>nn(r,s,t))),e.forEach((t=>nn(r,te[n]||{},t))),e.forEach((t=>nn(r,ne,t))),e.forEach((t=>nn(r,ee,t)))}));const l=Array.from(r);return 0===l.length&&l.push(Object.create(null)),en.has(e)&&o.set(e,l),l}chartOptionScopes(){const{options:t,type:e}=this;return[t,te[e]||{},ne.datasets[e]||{},{type:e},ne,ee]}resolveNamedOptions(t,e,i,n=[""]){const o={$shared:!0},{resolver:a,subPrefixes:r}=an(this._resolverCache,t,n);let l=a;if(function(t,e){const{isScriptable:i,isIndexable:n}=Ie(t);for(const o of e){const e=i(o),a=n(o),r=(a||e)&&t[o];if(e&&(k(r)||rn(r))||a&&s(r))return!0}return!1}(a,e)){o.$shared=!1;l=Re(a,i=k(i)?i():i,this.createResolver(t,i,r))}for(const t of e)o[t]=l[t];return o}createResolver(t,e,i=[""],s){const{resolver:o}=an(this._resolverCache,t,i);return n(e)?Re(o,e,void 0,s):o}}function an(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:Ee(e,i),subPrefixes:i.filter((t=>!t.toLowerCase().includes("hover")))},s.set(n,o)}return o}const rn=t=>n(t)&&Object.getOwnPropertyNames(t).reduce(((e,i)=>e||k(t[i])),!1);const ln=["top","bottom","left","right","chartArea"];function hn(t,e){return"top"===t||"bottom"===t||-1===ln.indexOf(t)&&"x"===e}function cn(t,e){return function(i,s){return i[t]===s[t]?i[e]-s[e]:i[t]-s[t]}}function dn(t){const e=t.chart,i=e.options.animation;e.notifyPlugins("afterRender"),c(i&&i.onComplete,[t],e)}function un(t){const e=t.chart,i=e.options.animation;c(i&&i.onProgress,[t],e)}function fn(t){return oe()&&"string"==typeof t?t=document.getElementById(t):t&&t.length&&(t=t[0]),t&&t.canvas&&(t=t.canvas),t}const gn={},pn=t=>{const e=fn(t);return Object.values(gn).filter((t=>t.canvas===e)).pop()};function mn(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 bn{constructor(t,i){const s=this.config=new on(i),n=fn(t),o=pn(n);if(o)throw new Error("Canvas is already in use. Chart with ID '"+o.id+"' must be destroyed before the canvas with ID '"+o.canvas.id+"' can be reused.");const a=s.createResolver(s.chartOptionScopes(),this.getContext());this.platform=new(s.platform||gs(n)),this.platform.updateConfig(s);const r=this.platform.acquireContext(n,a.aspectRatio),l=r&&r.canvas,h=l&&l.height,c=l&&l.width;this.id=e(),this.ctx=r,this.canvas=l,this.width=c,this.height=h,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 Xs,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=ct((t=>this.update(t)),a.resizeDelay||0),this._dataChanges=[],gn[this.id]=this,r&&l?(mt.listen(this,"complete",dn),mt.listen(this,"progress",un),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:s,height:n,_aspectRatio:o}=this;return i(t)?e&&o?o:n?s/n: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():pe(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins("afterInit"),this}clear(){return we(this.canvas,this.ctx),this}stop(){return mt.stop(this),this}resize(t,e){mt.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,pe(this,a,!0)&&(this.notifyPlugins("resize",{size:o}),c(i.onResize,[this,o],this),this.attached&&this._doResize(r)&&this.render())}ensureScalesHaveIDs(){d(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=Zs(t,i),n="r"===s,o="x"===s;return{options:i,dposition:n?"chartArea":o?"bottom":"left",dtype:n?"radialLinear":o?"category":"linear"}})))),d(n,(e=>{const n=e.options,o=n.id,a=Zs(o,n),l=r(n.type,e.dtype);void 0!==n.position&&hn(n.position,a)===hn(e.dposition)||(n.position=e.dposition),s[o]=!0;let h=null;if(o in i&&i[o].type===l)h=i[o];else{h=new(Us.getScale(l))({id:o,type:l,ctx:this.ctx,chart:this}),i[h.id]=h}h.init(n,t)})),d(s,((t,e)=>{t||delete i[e]})),d(i,(t=>{Zi.configure(this,t,t.options),Zi.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(cn("z","_idx"));const{_active:a,_lastEvent:r}=this;r?this._eventHandler(r,!0):a.length&&this._updateHoverStyles(a,a,!0),this.render()}_updateScales(){d(this.scales,(t=>{Zi.removeBox(this,t)})),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){const t=this.options,e=new Set(Object.keys(this._listeners)),i=new Set(t.events);S(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){mn(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;Zi.update(this,this.width,this.height,t);const e=this.chartArea,i=e.width<=0||e.height<=0;this._layers=[],d(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&&Pe(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&&De(e),o.cancelable=!1,this.notifyPlugins("afterDatasetDraw",o))}isPointInArea(t){return Se(t,this.chartArea,this._minPadding)}getElementsAtEventForMode(t,e,i,s){const n=Vi.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=_i(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);M(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(),mt.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)};d(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(){d(this._listeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._listeners={},d(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}}));!u(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=P(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,c(n.onHover,[t,a,this],this),r&&c(n.onClick,[t,a,this],this));const h=!u(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 xn=()=>d(bn.instances,(t=>t._plugins.invalidate())),_n=!0;function yn(){throw new Error("This method is not implemented: Check that a complete date adapter is provided.")}Object.defineProperties(bn,{defaults:{enumerable:_n,value:ne},instances:{enumerable:_n,value:gn},overrides:{enumerable:_n,value:te},registry:{enumerable:_n,value:Us},version:{enumerable:_n,value:"3.9.1"},getChart:{enumerable:_n,value:pn},register:{enumerable:_n,value:(...t)=>{Us.add(...t),xn()}},unregister:{enumerable:_n,value:(...t)=>{Us.remove(...t),xn()}}});class vn{constructor(t){this.options=t||{}}init(t){}formats(){return yn()}parse(t,e){return yn()}format(t,e){return yn()}add(t,e,i){return yn()}diff(t,e,i){return yn()}startOf(t,e,i){return yn()}endOf(t,e){return yn()}}vn.override=function(t){Object.assign(vn.prototype,t)};var wn={_date:vn};function Mn(t){const e=t.iScale,i=function(t,e){if(!t._cache.$bar){const i=t.getMatchingVisibleMetas(e);let s=[];for(let e=0,n=i.length;et-e)))}return t._cache.$bar}(e,t.type);let s,n,o,a,r=e._length;const l=()=>{32767!==o&&-32768!==o&&(M(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,n):e[i.axis]=i.parse(t,n),e}function Sn(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.baset.controller.options.grouped)),o=s.options.stacked,a=[],r=t=>{const s=t.controller.getParsed(e),n=s&&s[t.vScale.axis];if(i(n)||isNaN(n))return!0};for(const i of n)if((void 0===e||!r(i))&&((!1===o||-1===a.indexOf(i.stack)||void 0===o&&void 0===i.stack)&&a.push(i.stack),i.index===t))break;return a.length||a.push(void 0),a}_getStackCount(t){return this._getStacks(void 0,t).length}_getStackIndex(t,e,i){const s=this._getStacks(t,i),n=void 0!==e?s.indexOf(e):-1;return-1===n?s.length-1:n}_getRuler(){const t=this.options,e=this._cachedMeta,i=e.iScale,s=[];let n,o;for(n=0,o=e.data.length;n=i?1:-1)}(d,e,a)*o,u===a&&(m-=d/2);const t=e.getPixelForDecimal(0),i=e.getPixelForDecimal(1),s=Math.min(t,i),n=Math.max(t,i);m=Math.max(Math.min(m,n),s),c=m+d}if(m===e.getPixelForValue(a)){const t=z(d)*e.getLineWidthForValue(a)/2;m+=t,d-=t}return{size:d,base:m,head:c,center:c+d/2}}_calculateBarIndexPixels(t,e){const s=e.scale,n=this.options,o=n.skipNull,a=r(n.maxBarThickness,1/0);let l,h;if(e.grouped){const s=o?this._getStackCount(t):e.stackCount,r="flex"===n.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,{sharedOptions:r,includeOptions:l}=this._getSharedOptions(e,s),h=o.axis,c=a.axis;for(let d=e;d""}}}};class En extends Ls{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 o,a,r=t=>+i[t];if(n(i[t])){const{key:t="value"}=this._parsing;r=e=>+y(i[e],t)}for(o=t,a=t+e;oG(t,r,l,!0)?1:Math.max(e,e*i,s,s*i),g=(t,e,s)=>G(t,r,l,!0)?-1:Math.min(e,e*i,s,s*i),p=f(0,h,d),m=f(L,c,u),b=g(D,h,d),x=g(D+L,c,u);s=(p-b)/2,n=(m-x)/2,o=-(p+b)/2,a=-(m+x)/2}return{ratioX:s,ratioY:n,offsetX:o,offsetY:a}}(u,d,r),b=(i.width-o)/f,x=(i.height-o)/g,_=Math.max(Math.min(b,x)/2,0),y=h(this.options.radius,_),v=(y-Math.max(y*r,0))/this._getVisibleDatasetWeightTotal();this.offsetX=p*y,this.offsetY=m*y,s.total=this.calculateTotal(),this.outerRadius=y-v*this._getRingWeightOffset(this.index),this.innerRadius=Math.max(this.outerRadius-v*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/O)}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,{sharedOptions:f,includeOptions:g}=this._getSharedOptions(e,s);let p,m=this._getRotation();for(p=0;p0&&!isNaN(t)?O*(Math.abs(t)/e):0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=li(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},En.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 s(e)?(e=e.slice(),e[0]+=i):e+=i,e}}}}};class Rn extends Ls{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}=gt(e,s,o);this._drawStart=a,this._drawCount=r,pt(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,s,n){const o="reset"===n,{iScale:a,vScale:r,_stacked:l,_dataset:h}=this._cachedMeta,{sharedOptions:c,includeOptions:d}=this._getSharedOptions(e,n),u=a.axis,f=r.axis,{spanGaps:g,segment:p}=this.options,m=B(g)?g:Number.POSITIVE_INFINITY,b=this.chart._animationsDisabled||o||"none"===n;let x=e>0&&this.getParsed(e-1);for(let g=e;g0&&Math.abs(s[u]-x[u])>m,p&&(_.parsed=s,_.raw=h.data[g]),d&&(_.options=c||this.resolveDataElementOptions(g,e.active?"active":n)),b||this.updateElement(e,g,_,n),x=s}}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()}}Rn.id="line",Rn.defaults={datasetElementType:"line",dataElementType:"point",showLine:!0,spanGaps:!1},Rn.overrides={scales:{_index_:{type:"category"},_value_:{type:"linear"}}};class In extends Ls{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=li(e._parsed[t].r,i.options.locale);return{label:s[t]||"",value:n}}parseObjectData(t,e,i,s){return Ue.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*D;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)?H(this.resolveDataElementOptions(t,e).angle||i):0}}In.id="polarArea",In.defaults={dataElementType:"arc",animation:{animateRotate:!0,animateScale:!0},animations:{numbers:{type:"number",properties:["x","y","startAngle","endAngle","innerRadius","outerRadius"]}},indexAxis:"r",startAngle:0},In.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 zn extends En{}zn.id="pie",zn.defaults={cutout:0,rotation:0,circumference:360,radius:"100%"};class Fn extends Ls{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 Ue.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;a0&&this.getParsed(e-1);for(let c=e;c0&&Math.abs(s[f]-_[f])>b,m&&(p.parsed=s,p.raw=h.data[c]),u&&(p.options=d||this.resolveDataElementOptions(c,e.active?"active":n)),x||this.updateElement(e,c,p,n),_=s}this.updateSharedOptions(d,n,c)}getMaxOverflow(){const t=this._cachedMeta,e=t.data||[];if(!this.options.showLine){let t=0;for(let i=e.length-1;i>=0;--i)t=Math.max(t,e[i].size(this.resolveDataElementOptions(i))/2);return t>0&&t}const i=t.dataset,s=i.options&&i.options.borderWidth||0;if(!e.length)return s;const n=e[0].size(this.resolveDataElementOptions(0)),o=e[e.length-1].size(this.resolveDataElementOptions(e.length-1));return Math.max(s,n,o)/2}}Vn.id="scatter",Vn.defaults={datasetElementType:!1,dataElementType:"point",showLine:!1,fill:!1},Vn.overrides={interaction:{mode:"point"},plugins:{tooltip:{callbacks:{title:()=>"",label:t=>"("+t.label+", "+t.formattedValue+")"}}},scales:{x:{type:"linear"},y:{type:"linear"}}};var Bn=Object.freeze({__proto__:null,BarController:Tn,BubbleController:Ln,DoughnutController:En,LineController:Rn,PolarAreaController:In,PieController:zn,RadarController:Fn,ScatterController:Vn});function Nn(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+L,s-L),t.closePath(),t.clip()}function Wn(t,e,i,s){const n=ui(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 Z(t,0,Math.min(o,e))};return{outerStart:r(n.outerStart),outerEnd:r(n.outerEnd),innerStart:Z(n.innerStart,0,a),innerEnd:Z(n.innerEnd,0,a)}}function jn(t,e,i,s){return{x:i+t*Math.cos(e),y:s+t*Math.sin(e)}}function Hn(t,e,i,s,n,o){const{x:a,y:r,startAngle:l,pixelMargin:h,innerRadius:c}=e,d=Math.max(e.outerRadius+s+i-h,0),u=c>0?c+s+i+h:0;let f=0;const g=n-l;if(s){const t=((c>0?c-s:0)+(d>0?d-s:0))/2;f=(g-(0!==t?g*t/(t+s):g))/2}const p=(g-Math.max(.001,g*d-i/D)/d)/2,m=l+p+f,b=n-p-f,{outerStart:x,outerEnd:_,innerStart:y,innerEnd:v}=Wn(e,u,d,b-m),w=d-x,M=d-_,k=m+x/w,S=b-_/M,P=u+y,O=u+v,C=m+y/P,A=b-v/O;if(t.beginPath(),o){if(t.arc(a,r,d,k,S),_>0){const e=jn(M,S,a,r);t.arc(e.x,e.y,_,S,b+L)}const e=jn(O,b,a,r);if(t.lineTo(e.x,e.y),v>0){const e=jn(O,A,a,r);t.arc(e.x,e.y,v,b+L,A+Math.PI)}if(t.arc(a,r,u,b-v/u,m+y/u,!0),y>0){const e=jn(P,C,a,r);t.arc(e.x,e.y,y,C+Math.PI,m-L)}const i=jn(w,m,a,r);if(t.lineTo(i.x,i.y),x>0){const e=jn(w,k,a,r);t.arc(e.x,e.y,x,m-L,k)}}else{t.moveTo(a,r);const e=Math.cos(k)*d+a,i=Math.sin(k)*d+r;t.lineTo(e,i);const s=Math.cos(S)*d+a,n=Math.sin(S)*d+r;t.lineTo(s,n)}t.closePath()}function $n(t,e,i,s,n,o){const{options:a}=e,{borderWidth:r,borderJoinStyle:l}=a,h="inner"===a.borderAlign;r&&(h?(t.lineWidth=2*r,t.lineJoin=l||"round"):(t.lineWidth=r,t.lineJoin=l||"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&&Nn(t,e,o+O),t.beginPath(),t.arc(s,n,h,o+O,o,!0),c=0;c=O||G(n,a,l),g=Q(o,h+u,c+u);return f&&g}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,o=e.circular;if(this.pixelMargin="inner"===e.borderAlign?.33:0,this.fullCircles=i>O?Math.floor(i/O):0,0===i||this.innerRadius<0||this.outerRadius<0)return;t.save();let a=0;if(s){a=s/2;const e=(this.startAngle+this.endAngle)/2;t.translate(Math.cos(e)*a,Math.sin(e)*a),this.circumference>=D&&(a=s)}t.fillStyle=e.backgroundColor,t.strokeStyle=e.borderColor;const r=function(t,e,i,s,n){const{fullCircles:o,startAngle:a,circumference:r}=e;let l=e.endAngle;if(o){Hn(t,e,i,s,a+O,n);for(let e=0;er&&o>r;return{count:s,start:l,loop:e.loop,ilen:h(a+(h?r-t:t))%o,_=()=>{f!==g&&(t.lineTo(m,g),t.lineTo(m,f),t.lineTo(m,p))};for(l&&(d=n[x(0)],t.moveTo(d.x,d.y)),c=0;c<=r;++c){if(d=n[x(c)],d.skip)continue;const e=d.x,i=d.y,s=0|e;s===u?(ig&&(g=i),m=(b*m+e)/++b):(_(),t.lineTo(e,i),u=s,b=0,f=g=i),p=i}_()}function Zn(t){const e=t.options,i=e.borderDash&&e.borderDash.length;return!(t._decimated||t._loop||e.tension||"monotone"===e.cubicInterpolationMode||e.stepped||i)?Gn:Kn}Yn.id="arc",Yn.defaults={borderAlign:"center",borderColor:"#fff",borderJoinStyle:void 0,borderRadius:0,borderWidth:2,offset:0,spacing:0,angle:void 0,circular:!0},Yn.defaultRoutes={backgroundColor:"backgroundColor"};const Jn="function"==typeof Path2D;function Qn(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()),Un(t,e.options),t.stroke(n)}(t,e,i,s):function(t,e,i,s){const{segments:n,options:o}=e,a=Zn(e);for(const r of n)Un(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 to extends Es{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=Di(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=Pi(this,{property:e,start:s,end:s});if(!o.length)return;const a=[],r=function(t){return t.stepped?oi:t.tension||"monotone"===t.cubicInterpolationMode?ai:ni}(i);let l,h;for(l=0,h=o.length;l"borderDash"!==t&&"fill"!==t};class io extends Es{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){uo(t)}))}var go={id:"decimation",defaults:{algorithm:"min-max",enabled:!1},beforeElementsUpdate:(t,e,s)=>{if(!s.enabled)return void fo(t);const n=t.width;t.data.datasets.forEach(((e,o)=>{const{_data:a,indexAxis:r}=e,l=t.getDatasetMeta(o),h=a||e.data;if("y"===bi([r,t.options.indexAxis]))return;if(!l.controller.supportsDecimation)return;const c=t.scales[l.xAxisID];if("linear"!==c.type&&"time"!==c.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=Z(et(e,o.axis,a).lo,0,i-1)),s=h?Z(et(e,o.axis,r).hi+1,n,i)-n:i-n,{start:n,count:s}}(l,h);if(u<=(s.threshold||4*n))return void uo(e);let f;switch(i(a)&&(e._data=h,delete e.data,Object.defineProperty(e,"data",{configurable:!0,enumerable:!0,get:function(){return this._decimated},set:function(t){this._data=t}})),s.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}(h,d,u,n,s);break;case"min-max":f=function(t,e,s,n){let o,a,r,l,h,c,d,u,f,g,p=0,m=0;const b=[],x=e+s-1,_=t[e].x,y=t[x].x-_;for(o=e;og&&(g=l,d=o),p=(m*p+a.x)/++m;else{const s=o-1;if(!i(c)&&!i(d)){const e=Math.min(c,d),i=Math.max(c,d);e!==u&&e!==s&&b.push({...t[e],x:p}),i!==u&&i!==s&&b.push({...t[i],x:p})}o>0&&s!==u&&b.push(t[s]),b.push(a),h=e,m=0,f=g=l,c=d=u=o}}return b}(h,d,u,n);break;default:throw new Error(`Unsupported decimation algorithm '${s.algorithm}'`)}e._decimated=f}))},destroy(t){fo(t)}};function po(t,e,i,s){if(s)return;let n=e[t],o=i[t];return"angle"===t&&(n=K(n),o=K(o)),{property:t,start:n,end:o}}function mo(t,e,i){for(;e>t;e--){const t=i[e];if(!isNaN(t.x)&&!isNaN(t.y))break}return e}function bo(t,e,i,s){return t&&e?s(t[i],e[i]):t?t[i]:e?e[i]:0}function xo(t,e){let i=[],n=!1;return s(t)?(n=!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=mo(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 to({points:i,options:{tension:0},_loop:n,_fullLoop:n}):null}function _o(t){return t&&!1!==t.fill}function yo(t,e,i){let s=t[e].fill;const n=[e];let a;if(!i)return s;for(;!1!==s&&-1===n.indexOf(s);){if(!o(s))return s;if(a=t[s],!a)return!1;if(a.visible)return s;n.push(s),s=a.fill}return!1}function vo(t,e,i){const s=function(t){const e=t.options,i=e.fill;let s=r(i&&i.target,i);void 0===s&&(s=!!e.backgroundColor);if(!1===s||null===s)return!1;if(!0===s)return"origin";return s}(t);if(n(s))return!isNaN(s.value)&&s;let a=parseFloat(s);return o(a)&&Math.floor(a)===a?function(t,e,i,s){"-"!==t&&"+"!==t||(i=e+i);if(i===e||i<0||i>=s)return!1;return i}(s[0],e,a,i):["origin","start","end","stack","shape"].indexOf(s)>=0&&s}function wo(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&&i.fill&&Po(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;_o(i)&&Po(t.ctx,i,t.chartArea)}},beforeDatasetDraw(t,e,i){const s=e.meta.$filler;_o(s)&&"beforeDatasetDraw"===i.drawTime&&Po(t.ctx,s,t.chartArea)},defaults:{propagate:!0,drawTime:"beforeDatasetDraw"}};const Lo=(t,e)=>{let{boxHeight:i=e,boxWidth:s=e}=t;return t.usePointStyle&&(i=Math.min(i,e),s=t.pointStyleWidth||Math.min(s,e)),{boxWidth:s,boxHeight:i,itemHeight:Math.max(e,i)}};class Eo extends Es{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=c(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=mi(i.font),n=s.size,o=this._computeTitleHeight(),{boxWidth:a,itemHeight:r}=Lo(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=yi(n,this.left,this.width);if(this.isHorizontal()){let n=0,a=ut(i,this.left+s,this.right-this.lineWidths[n]);for(const r of e)n!==r.row&&(n=r.row,a=ut(i,this.left+s,this.right-this.lineWidths[n])),r.top+=this.top+t+s,r.left=o.leftForLtr(o.x(a),r.width),a+=r.width+s}else{let n=0,a=ut(i,this.top+t+s,this.bottom-this.columnSizes[n].height);for(const r of e)r.col!==n&&(n=r.col,a=ut(i,this.top+t+s,this.bottom-this.columnSizes[n].height)),r.top=a,r.left+=this.left+s,r.left=o.leftForLtr(o.x(r.left),r.width),a+=r.height+s}}isHorizontal(){return"top"===this.options.position||"bottom"===this.options.position}draw(){if(this.options.display){const t=this.ctx;Pe(t,this),this._draw(),De(t)}}_draw(){const{options:t,columnSizes:e,lineWidths:i,ctx:s}=this,{align:n,labels:o}=t,a=ne.color,l=yi(t.rtl,this.left,this.width),h=mi(o.font),{color:c,padding:d}=o,u=h.size,f=u/2;let g;this.drawTitle(),s.textAlign=l.textAlign("left"),s.textBaseline="middle",s.lineWidth=.5,s.font=h.string;const{boxWidth:p,boxHeight:m,itemHeight:b}=Lo(o,u),x=this.isHorizontal(),_=this._computeTitleHeight();g=x?{x:ut(n,this.left+d,this.right-i[0]),y:this.top+d+_,line:0}:{x:this.left+d,y:ut(n,this.top+_+d,this.bottom-e[0].height),line:0},vi(this.ctx,t.textDirection);const y=b+d;this.legendItems.forEach(((v,w)=>{s.strokeStyle=v.fontColor||c,s.fillStyle=v.fontColor||c;const M=s.measureText(v.text).width,k=l.textAlign(v.textAlign||(v.textAlign=o.textAlign)),S=p+f+M;let P=g.x,D=g.y;l.setWidth(this.width),x?w>0&&P+S+d>this.right&&(D=g.y+=y,g.line++,P=g.x=ut(n,this.left+d,this.right-i[g.line])):w>0&&D+y>this.bottom&&(P=g.x=P+e[g.line].width+d,g.line++,D=g.y=ut(n,this.top+_+d,this.bottom-e[g.line].height));!function(t,e,i){if(isNaN(p)||p<=0||isNaN(m)||m<0)return;s.save();const n=r(i.lineWidth,1);if(s.fillStyle=r(i.fillStyle,a),s.lineCap=r(i.lineCap,"butt"),s.lineDashOffset=r(i.lineDashOffset,0),s.lineJoin=r(i.lineJoin,"miter"),s.lineWidth=n,s.strokeStyle=r(i.strokeStyle,a),s.setLineDash(r(i.lineDash,[])),o.usePointStyle){const a={radius:m*Math.SQRT2/2,pointStyle:i.pointStyle,rotation:i.rotation,borderWidth:n},r=l.xPlus(t,p/2);ke(s,a,r,e+f,o.pointStyleWidth&&p)}else{const o=e+Math.max((u-m)/2,0),a=l.leftForLtr(t,p),r=gi(i.borderRadius);s.beginPath(),Object.values(r).some((t=>0!==t))?Le(s,{x:a,y:o,w:p,h:m,radius:r}):s.rect(a,o,p,m),s.fill(),0!==n&&s.stroke()}s.restore()}(l.x(P),D,v),P=ft(k,P+p+f,x?P+S:this.right,t.rtl),function(t,e,i){Ae(s,i.text,t,e+b/2,h,{strikethrough:i.hidden,textAlign:l.textAlign(i.textAlign)})}(l.x(P),D,v),x?g.x+=S+d:g.y+=y})),wi(this.ctx,t.textDirection)}drawTitle(){const t=this.options,e=t.title,i=mi(e.font),s=pi(e.padding);if(!e.display)return;const n=yi(t.rtl,this.left,this.width),o=this.ctx,a=e.position,r=i.size/2,l=s.top+r;let h,c=this.left,d=this.width;if(this.isHorizontal())d=Math.max(...this.lineWidths),h=this.top+l,c=ut(t.align,c,this.right-d);else{const e=this.columnSizes.reduce(((t,e)=>Math.max(t,e.height)),0);h=l+ut(t.align,this.top,this.bottom-e-t.labels.padding-this._computeTitleHeight())}const u=ut(a,c,c+d);o.textAlign=n.textAlign(dt(a)),o.textBaseline="middle",o.strokeStyle=e.color,o.fillStyle=e.color,o.font=i.string,Ae(o,e.text,u,h,i)}_computeTitleHeight(){const t=this.options.title,e=mi(t.font),i=pi(t.padding);return t.display?e.lineHeight+i.height:0}_getLegendItemAt(t,e){let i,s,n;if(Q(t,this.left,this.right)&&Q(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=pi(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 Io extends Es{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 n=s(i.text)?i.text.length:1;this._padding=pi(i.padding);const o=n*mi(i.font).lineHeight+this._padding.height;this.isHorizontal()?this.height=o:this.width=o}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,a=o.align;let r,l,h,c=0;return this.isHorizontal()?(l=ut(a,i,n),h=e+t,r=n-i):("left"===o.position?(l=i+t,h=ut(a,s,e),c=-.5*D):(l=n-t,h=ut(a,e,s),c=.5*D),r=s-e),{titleX:l,titleY:h,maxWidth:r,rotation:c}}draw(){const t=this.ctx,e=this.options;if(!e.display)return;const i=mi(e.font),s=i.lineHeight/2+this._padding.top,{titleX:n,titleY:o,maxWidth:a,rotation:r}=this._drawArgs(s);Ae(t,e.text,0,0,i,{color:e.color,maxWidth:a,rotation:r,textAlign:dt(e.align),textBaseline:"middle",translation:[n,o]})}}var zo={id:"title",_element:Io,start(t,e,i){!function(t,e){const i=new Io({ctx:t.ctx,options:e,chart:t});Zi.configure(t,i,e),Zi.addBox(t,i),t.titleBlock=i}(t,i)},stop(t){const e=t.titleBlock;Zi.removeBox(t,e),delete t.titleBlock},beforeUpdate(t,e,i){const s=t.titleBlock;Zi.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 Fo=new WeakMap;var Vo={id:"subtitle",start(t,e,i){const s=new Io({ctx:t.ctx,options:i,chart:t});Zi.configure(t,s,i),Zi.addBox(t,s),Fo.set(t,s)},stop(t){Zi.removeBox(t,Fo.get(t)),Fo.delete(t)},beforeUpdate(t,e,i){const s=Fo.get(t);Zi.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 Bo={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 jo(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 Ho(t,e){const i=t.chart.ctx,{body:s,footer:n,title:o}=t,{boxWidth:a,boxHeight:r}=e,l=mi(e.bodyFont),h=mi(e.titleFont),c=mi(e.footerFont),u=o.length,f=n.length,g=s.length,p=pi(e.padding);let m=p.height,b=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,u&&(m+=u*h.lineHeight+(u-1)*e.titleSpacing+e.titleMarginBottom),x){m+=g*(e.displayColors?Math.max(r,l.lineHeight):l.lineHeight)+(x-g)*l.lineHeight+(x-1)*e.bodySpacing}f&&(m+=e.footerMarginTop+f*c.lineHeight+(f-1)*e.footerSpacing);let _=0;const y=function(t){b=Math.max(b,i.measureText(t).width+_)};return i.save(),i.font=h.string,d(t.title,y),i.font=l.string,d(t.beforeBody.concat(t.afterBody),y),_=e.displayColors?a+2+e.boxPadding:0,d(s,(t=>{d(t.before,y),d(t.lines,y),d(t.after,y)})),_=0,i.font=c.string,d(t.footer,y),i.restore(),b+=p.width,{width:b,height:m}}function $o(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 Yo(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||$o(t,e,i,s),yAlign:s}}function Uo(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}=gi(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:Z(g,0,s.width-e.width),y:Z(p,0,s.height-e.height)}}function Xo(t,e,i){const s=pi(i.padding);return"center"===e?t.x+t.width/2:"right"===e?t.x+t.width-s.right:t.x+s.left}function qo(t){return No([],Wo(t))}function Ko(t,e){const i=e&&e.dataset&&e.dataset.tooltip&&e.dataset.tooltip.callbacks;return i?t.override(i):t}class Go extends Es{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 ys(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,_i(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=No(a,Wo(s)),a=No(a,Wo(n)),a=No(a,Wo(o)),a}getBeforeBody(t,e){return qo(e.callbacks.beforeBody.apply(this,[t]))}getBody(t,e){const{callbacks:i}=e,s=[];return d(t,(t=>{const e={before:[],lines:[],after:[]},n=Ko(i,t);No(e.before,Wo(n.beforeLabel.call(this,t))),No(e.lines,n.label.call(this,t)),No(e.after,Wo(n.afterLabel.call(this,t))),s.push(e)})),s}getAfterBody(t,e){return qo(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=No(a,Wo(s)),a=No(a,Wo(n)),a=No(a,Wo(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)))),d(l,(e=>{const i=Ko(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=Bo[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=Ho(this,i),a=Object.assign({},t,e),r=Yo(this.chart,i,a),l=Uo(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}=gi(a),{x:d,y:u}=t,{width:f,height:g}=e;let p,m,b,x,_,y;return"center"===n?(_=u+g/2,"left"===s?(p=d,m=p-o,x=_+o,y=_-o):(p=d+f,m=p+o,x=_-o,y=_+o),b=p):(m="left"===s?d+Math.max(r,h)+o:"right"===s?d+f-Math.max(l,c)-o:this.caretX,"top"===n?(x=u,_=x-o,p=m-o,b=m+o):(x=u+g,_=x+o,p=m+o,b=m-o),y=x),{x1:p,x2:m,x3:b,y1:x,y2:_,y3:y}}drawTitle(t,e,i){const s=this.title,n=s.length;let o,a,r;if(n){const l=yi(i.rtl,this.x,this.width);for(t.x=Xo(this,i.titleAlign,i),e.textAlign=l.textAlign(i.titleAlign),e.textBaseline="middle",o=mi(i.titleFont),a=i.titleSpacing,e.fillStyle=i.titleColor,e.font=o.string,r=0;r0!==t))?(t.beginPath(),t.fillStyle=o.multiKeyBackground,Le(t,{x:e,y:p,w:h,h:l,radius:r}),t.fill(),t.stroke(),t.fillStyle=a.backgroundColor,t.beginPath(),Le(t,{x:i,y:p+1,w:h-2,h:l-2,radius:r}),t.fill()):(t.fillStyle=o.multiKeyBackground,t.fillRect(e,p,h,l),t.strokeRect(e,p,h,l),t.fillStyle=a.backgroundColor,t.fillRect(i,p+1,h-2,l-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=mi(i.bodyFont);let u=c.lineHeight,f=0;const g=yi(i.rtl,this.x,this.width),p=function(i){e.fillText(i,g.x(t.x+f),t.y+u/2),t.y+=u+n},m=g.textAlign(o);let b,x,_,y,v,w,M;for(e.textAlign=o,e.textBaseline="middle",e.font=c.string,t.x=Xo(this,m,i),e.fillStyle=i.bodyColor,d(this.beforeBody,p),f=a&&"right"!==m?"center"===o?l/2+h:l+2+h:0,y=0,w=s.length;y0&&e.stroke()}_updateAnimationTarget(t){const e=this.chart,i=this.$animations,s=i&&i.x,n=i&&i.y;if(s||n){const i=Bo[t.position].call(this,this._active,this._eventPosition);if(!i)return;const o=this._size=Ho(this,t),a=Object.assign({},i,this._size),r=Yo(e,t,a),l=Uo(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=pi(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),vi(t,e.textDirection),n.y+=o.top,this.drawTitle(n,t,e),this.drawBody(n,t,e),this.drawFooter(n,t,e),wi(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=!u(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||!u(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=Bo[n.position].call(this,t,e);return!1!==o&&(i!==o.x||s!==o.y)}}Go.positioners=Bo;var Zo={id:"tooltip",_element:Go,positioners:Bo,afterInit(t,e,i){i&&(t.tooltip=new Go({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:t,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"]},Jo=Object.freeze({__proto__:null,Decimation:go,Filler:To,Legend:Ro,SubTitle:Vo,Title:zo,Tooltip:Zo});function Qo(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 ta extends $s{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(i(t))return null;const s=this.getLabels();return((t,e)=>null===t?null:Z(Math.round(t),0,e))(e=isFinite(e)&&s[e]===t?e:Qo(s,t,r(e,t),this._addedLabels),s.length-1)}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 ea(t,e,{horizontal:i,minRotation:s}){const n=H(s),o=(i?Math.sin(n):Math.cos(n))||.001,a=.75*e*(""+t).length;return Math.min(e/o,a)}ta.id="category",ta.defaults={ticks:{callback:ta.prototype.getLabelForValue}};class ia extends $s{constructor(t){super(t),this.start=void 0,this.end=void 0,this._startValue=void 0,this._endValue=void 0,this._valueRange=0}parse(t,e){return i(t)||("number"==typeof t||t instanceof Number)&&!isFinite(+t)?null:+t}handleTickRangeOptions(){const{beginAtZero:t}=this.options,{minDefined:e,maxDefined:i}=this.getUserBounds();let{min:s,max:n}=this;const o=t=>s=e?s:t,a=t=>n=i?n:t;if(t){const t=z(s),e=z(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 s=this.getTickLimit();s=Math.max(2,s);const n=function(t,e){const s=[],{bounds:n,step:o,min:a,max:r,precision:l,count:h,maxTicks:c,maxDigits:d,includeBounds:u}=t,f=o||1,g=c-1,{min:p,max:m}=e,b=!i(a),x=!i(r),_=!i(h),y=(m-p)/(d+1);let v,w,M,k,S=F((m-p)/g/f)*f;if(S<1e-14&&!b&&!x)return[{value:p},{value:m}];k=Math.ceil(m/S)-Math.floor(p/S),k>g&&(S=F(k*S/g/f)*f),i(l)||(v=Math.pow(10,l),S=Math.ceil(S*v)/v),"ticks"===n?(w=Math.floor(p/S)*S,M=Math.ceil(m/S)*S):(w=p,M=m),b&&x&&o&&W((r-a)/o,S/1e3)?(k=Math.round(Math.min((r-a)/S,c)),S=(r-a)/k,w=a,M=r):_?(w=b?a:w,M=x?r:M,k=h-1,S=(M-w)/k):(k=(M-w)/S,k=N(k,Math.round(k),S/1e3)?Math.round(k):Math.ceil(k));const P=Math.max(Y(S),Y(w));v=Math.pow(10,i(l)?P:l),w=Math.round(w*v)/v,M=Math.round(M*v)/v;let D=0;for(b&&(u&&w!==a?(s.push({value:a}),w0?i:null;this._zero=!0}determineDataLimits(){const{min:t,max:e}=this.getMinMax(!0);this.min=o(t)?Math.max(0,t):null,this.max=o(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(I(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(I(e.max)),s=Math.ceil(e.max/Math.pow(10,i)),n=[];let o=a(t.min,Math.pow(10,Math.floor(I(e.min)))),r=Math.floor(I(o)),l=Math.floor(o/Math.pow(10,r)),h=r<0?Math.pow(10,Math.abs(r)):1;do{n.push({value:o,major:na(o)}),++l,10===l&&(l=1,++r,h=r>=0?1:h),o=Math.round(l*Math.pow(10,r)*h)/h}while(rn?{start:e-i,end:e}:{start:e,end:e+i}}function la(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),n=[],o=[],a=t._pointLabels.length,r=t.options.pointLabels,l=r.centerPointLabels?D/a: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 ca(t){return 0===t||180===t?"center":t<180?"left":"right"}function da(t,e,i){return"right"===i?t-=e:"center"===i&&(t-=e/2),t}function ua(t,e,i){return 90===i||270===i?t-=e/2:(i>270||i<90)&&(t-=e),t}function fa(t,e,i,s){const{ctx:n}=t;if(i)n.arc(t.xCenter,t.yCenter,e,0,O);else{let i=t.getPointPosition(0,e);n.moveTo(i.x,i.y);for(let o=1;o{const i=c(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?la(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 K(t*(O/(this._pointLabels.length||1))+H(this.options.startAngle||0))}getDistanceFromCenterForValue(t){if(i(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(i(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;o--){const e=n.setContext(t.getPointLabelContext(o)),a=mi(e.font),{x:r,y:l,textAlign:h,left:c,top:d,right:u,bottom:f}=t._pointLabelItems[o],{backdropColor:g}=e;if(!i(g)){const t=gi(e.borderRadius),i=pi(e.backdropPadding);s.fillStyle=g;const n=c-i.left,o=d-i.top,a=u-c+i.width,r=f-d+i.height;Object.values(t).some((t=>0!==t))?(s.beginPath(),Le(s,{x:n,y:o,w:a,h:r,radius:t}),s.fill()):s.fillRect(n,o,a,r)}Ae(s,t._pointLabels[o],r,l+a.lineHeight/2,a,{color:e.color,textAlign:h,textBaseline:"middle"})}}(this,o),n.display&&this.ticks.forEach(((t,e)=>{if(0!==e){r=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(),fa(t,i,o,s),n.closePath(),n.stroke(),n.restore())}(this,n.setContext(this.getContext(e-1)),r,o)}})),s.display){for(t.save(),a=o-1;a>=0;a--){const i=s.setContext(this.getPointLabelContext(a)),{color:n,lineWidth:o}=i;o&&n&&(t.lineWidth=o,t.strokeStyle=n,t.setLineDash(i.borderDash),t.lineDashOffset=i.borderDashOffset,r=this.getDistanceFromCenterForValue(e.ticks.reverse?this.min:this.max),l=this.getPointPosition(a,r),t.beginPath(),t.moveTo(this.xCenter,this.yCenter),t.lineTo(l.x,l.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=mi(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=pi(r.backdropPadding);t.fillRect(-o/2-e.left,-n-l.size/2-e.top,o+e.width,l.size+e.height)}Ae(t,s.label,0,-n,l,{color:r.color})})),t.restore()}drawTitle(){}}ga.id="radialLinear",ga.defaults={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:Is.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback:t=>t,padding:5,centerPointLabels:!1}},ga.defaultRoutes={"angleLines.color":"borderColor","pointLabels.color":"color","ticks.color":"color"},ga.descriptors={angleLines:{_fallback:"grid"}};const pa={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}},ma=Object.keys(pa);function ba(t,e){return t-e}function xa(t,e){if(i(e))return null;const s=t._adapter,{parser:n,round:a,isoWeekday:r}=t._parseOpts;let l=e;return"function"==typeof n&&(l=n(l)),o(l)||(l="string"==typeof n?s.parse(l,n):s.parse(l)),null===l?null:(a&&(l="week"!==a||!B(r)&&!0!==r?s.startOf(l,a):s.startOf(l,"isoWeek",r)),+l)}function _a(t,e,i,s){const n=ma.length;for(let o=ma.indexOf(t);o=e?i[s]:i[n]]=!0}}else t[e]=!0}function va(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 wa extends $s{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 wn._date(t.adapters.date);s.init(e),b(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:xa(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:a,maxDefined:r}=this.getUserBounds();function l(t){a||isNaN(t.min)||(s=Math.min(s,t.min)),r||isNaN(t.max)||(n=Math.max(n,t.max))}a&&r||(l(this._getLabelBounds()),"ticks"===t.bounds&&"labels"===t.ticks.source||l(this.getMinMax(!1))),s=o(s)&&!isNaN(s)?s:+e.startOf(Date.now(),i),n=o(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=st(s,n,this.max);return this._unit=e.unit||(i.autoSkip?_a(e.minUnit,this.min,this.max,this._getLabelCapacity(n)):function(t,e,i,s,n){for(let o=ma.length-1;o>=ma.indexOf(i);o--){const i=ma[o];if(pa[i].common&&t._adapter.diff(n,s,i)>=e-1)return i}return ma[i?ma.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=ma.indexOf(t)+1,i=ma.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=Z(s,0,o),n=Z(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||_a(n.minUnit,e,i,this._getLabelCapacity(e)),a=r(n.stepSize,1),l="week"===o&&n.isoWeekday,h=B(l)||!0===l,c={};let d,u,f=e;if(h&&(f=+t.startOf(f,"isoWeek",l)),f=+t.startOf(f,h?"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 g="data"===s.ticks.source&&this.getDataTimestamps();for(d=f,u=0;dt-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],d=i[e],u=r&&h&&d&&d.major,f=this._adapter.format(t,s||(u?h:l)),g=n.ticks.callback;return g?c(g,[f,e,i],this):f}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}=et(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}=et(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}wa.id="time",wa.defaults={bounds:"data",adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{}},ticks:{source:"auto",major:{enabled:!1}}};class ka extends wa{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=Ma(e,this.min),this._tableRange=Ma(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 Date: Mon, 29 Sep 2025 14:30:30 +0200 Subject: [PATCH 3/4] Update chartjs-adapter-date-fns.bundle.min.js --- .../modules/chart.js/chartjs-adapter-date-fns.bundle.min.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/www/ftui/modules/chart.js/chartjs-adapter-date-fns.bundle.min.js b/www/ftui/modules/chart.js/chartjs-adapter-date-fns.bundle.min.js index cdd007a1..37bffe67 100755 --- a/www/ftui/modules/chart.js/chartjs-adapter-date-fns.bundle.min.js +++ b/www/ftui/modules/chart.js/chartjs-adapter-date-fns.bundle.min.js @@ -1,7 +1,7 @@ /*! - * chartjs-adapter-date-fns v1.0.0 + * chartjs-adapter-date-fns v3.0.0 * https://www.chartjs.org - * (c) 2020 Chart.js Contributors + * (c) 2022 chartjs-adapter-date-fns Contributors * Released under the MIT license */ -!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(require("chart.js")):"function"==typeof define&&define.amd?define(["chart.js"],e):e((t=t||self).Chart)}(this,(function(t){"use strict";function e(t){if(null===t||!0===t||!1===t)return NaN;var e=Number(t);return isNaN(e)?e:e<0?Math.ceil(e):Math.floor(e)}function r(t,e){if(e.length1?"s":" required, but only "+e.length+" present")}function n(t){r(1,arguments);var e=Object.prototype.toString.call(t);return t instanceof Date||"object"==typeof t&&"[object Date]"===e?new Date(t.getTime()):"number"==typeof t||"[object Number]"===e?new Date(t):("string"!=typeof t&&"[object String]"!==e||"undefined"==typeof console||(console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as arguments. Please use `parseISO` to parse strings. See: https://git.io/fjule"),console.warn((new Error).stack)),new Date(NaN))}function a(t,a){r(2,arguments);var i=n(t),o=e(a);return i.setDate(i.getDate()+o),i}function i(t){r(1,arguments);var e=n(t),a=e.getFullYear(),i=e.getMonth(),o=new Date(0);return o.setFullYear(a,i+1,0),o.setHours(0,0,0,0),o.getDate()}function o(t,a){r(2,arguments);var o=n(t),u=e(a),s=o.getMonth()+u,c=new Date(0);c.setFullYear(o.getFullYear(),s,1),c.setHours(0,0,0,0);var d=i(c);return o.setMonth(s,Math.min(d,o.getDate())),o}function u(t,a){r(2,arguments);var i=n(t).getTime(),o=e(a);return new Date(i+o)}function s(t,a){r(1,arguments);var i=a||{},o=i.locale,u=o&&o.options&&o.options.weekStartsOn,s=null==u?0:e(u),c=null==i.weekStartsOn?s:e(i.weekStartsOn);if(!(c>=0&&c<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");var d=n(t),l=d.getDay(),f=(l0?1:o}function h(t){r(1,arguments);var e=n(t);return!isNaN(e)}function m(t,e){r(2,arguments);var a=n(t),i=n(e),o=a.getFullYear()-i.getFullYear(),u=a.getMonth()-i.getMonth();return 12*o+u}function w(t,e){r(2,arguments);var a=n(t),i=n(e);return a.getFullYear()-i.getFullYear()}function g(t,e){r(2,arguments);var a=n(t),i=n(e),o=f(a,i),u=Math.abs(l(a,i));a.setDate(a.getDate()-o*u);var s=f(a,i)===-o,c=o*(u-s);return 0===c?0:c}function v(t,e){r(2,arguments);var a=n(t),i=n(e);return a.getTime()-i.getTime()}function y(t,e){r(2,arguments);var a=n(t),i=n(e),o=f(a,i),u=Math.abs(m(a,i));a.setMonth(a.getMonth()-o*u);var s=f(a,i)===-o,c=o*(u-s);return 0===c?0:c}var b={lessThanXSeconds:{one:"less than a second",other:"less than {{count}} seconds"},xSeconds:{one:"1 second",other:"{{count}} seconds"},halfAMinute:"half a minute",lessThanXMinutes:{one:"less than a minute",other:"less than {{count}} minutes"},xMinutes:{one:"1 minute",other:"{{count}} minutes"},aboutXHours:{one:"about 1 hour",other:"about {{count}} hours"},xHours:{one:"1 hour",other:"{{count}} hours"},xDays:{one:"1 day",other:"{{count}} days"},aboutXMonths:{one:"about 1 month",other:"about {{count}} months"},xMonths:{one:"1 month",other:"{{count}} months"},aboutXYears:{one:"about 1 year",other:"about {{count}} years"},xYears:{one:"1 year",other:"{{count}} years"},overXYears:{one:"over 1 year",other:"over {{count}} years"},almostXYears:{one:"almost 1 year",other:"almost {{count}} years"}};function p(t){return function(e){var r=e||{},n=r.width?String(r.width):t.defaultWidth;return t.formats[n]||t.formats[t.defaultWidth]}}var T={date:p({formats:{full:"EEEE, MMMM do, y",long:"MMMM do, y",medium:"MMM d, y",short:"MM/dd/yyyy"},defaultWidth:"full"}),time:p({formats:{full:"h:mm:ss a zzzz",long:"h:mm:ss a z",medium:"h:mm:ss a",short:"h:mm a"},defaultWidth:"full"}),dateTime:p({formats:{full:"{{date}} 'at' {{time}}",long:"{{date}} 'at' {{time}}",medium:"{{date}}, {{time}}",short:"{{date}}, {{time}}"},defaultWidth:"full"})},C={lastWeek:"'last' eeee 'at' p",yesterday:"'yesterday at' p",today:"'today at' p",tomorrow:"'tomorrow at' p",nextWeek:"eeee 'at' p",other:"P"};function x(t){return function(e,r){var n,a=r||{};if("formatting"===(a.context?String(a.context):"standalone")&&t.formattingValues){var i=t.defaultFormattingWidth||t.defaultWidth,o=a.width?String(a.width):i;n=t.formattingValues[o]||t.formattingValues[i]}else{var u=t.defaultWidth,s=a.width?String(a.width):t.defaultWidth;n=t.values[s]||t.values[u]}return n[t.argumentCallback?t.argumentCallback(e):e]}}function M(t){return function(e,r){var n=String(e),a=r||{},i=a.width,o=i&&t.matchPatterns[i]||t.matchPatterns[t.defaultMatchWidth],u=n.match(o);if(!u)return null;var s,c=u[0],d=i&&t.parsePatterns[i]||t.parsePatterns[t.defaultParseWidth];return s="[object Array]"===Object.prototype.toString.call(d)?function(t,e){for(var r=0;r0?"in "+n:n+" ago":n},formatLong:T,formatRelative:function(t,e,r,n){return C[t]},localize:{ordinalNumber:function(t,e){var r=Number(t),n=r%100;if(n>20||n<10)switch(n%10){case 1:return r+"st";case 2:return r+"nd";case 3:return r+"rd"}return r+"th"},era:x({values:{narrow:["B","A"],abbreviated:["BC","AD"],wide:["Before Christ","Anno Domini"]},defaultWidth:"wide"}),quarter:x({values:{narrow:["1","2","3","4"],abbreviated:["Q1","Q2","Q3","Q4"],wide:["1st quarter","2nd quarter","3rd quarter","4th quarter"]},defaultWidth:"wide",argumentCallback:function(t){return Number(t)-1}}),month:x({values:{narrow:["J","F","M","A","M","J","J","A","S","O","N","D"],abbreviated:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],wide:["January","February","March","April","May","June","July","August","September","October","November","December"]},defaultWidth:"wide"}),day:x({values:{narrow:["S","M","T","W","T","F","S"],short:["Su","Mo","Tu","We","Th","Fr","Sa"],abbreviated:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],wide:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]},defaultWidth:"wide"}),dayPeriod:x({values:{narrow:{am:"a",pm:"p",midnight:"mi",noon:"n",morning:"morning",afternoon:"afternoon",evening:"evening",night:"night"},abbreviated:{am:"AM",pm:"PM",midnight:"midnight",noon:"noon",morning:"morning",afternoon:"afternoon",evening:"evening",night:"night"},wide:{am:"a.m.",pm:"p.m.",midnight:"midnight",noon:"noon",morning:"morning",afternoon:"afternoon",evening:"evening",night:"night"}},defaultWidth:"wide",formattingValues:{narrow:{am:"a",pm:"p",midnight:"mi",noon:"n",morning:"in the morning",afternoon:"in the afternoon",evening:"in the evening",night:"at night"},abbreviated:{am:"AM",pm:"PM",midnight:"midnight",noon:"noon",morning:"in the morning",afternoon:"in the afternoon",evening:"in the evening",night:"at night"},wide:{am:"a.m.",pm:"p.m.",midnight:"midnight",noon:"noon",morning:"in the morning",afternoon:"in the afternoon",evening:"in the evening",night:"at night"}},defaultFormattingWidth:"wide"})},match:{ordinalNumber:(D={matchPattern:/^(\d+)(th|st|nd|rd)?/i,parsePattern:/\d+/i,valueCallback:function(t){return parseInt(t,10)}},function(t,e){var r=String(t),n=e||{},a=r.match(D.matchPattern);if(!a)return null;var i=a[0],o=r.match(D.parsePattern);if(!o)return null;var u=D.valueCallback?D.valueCallback(o[0]):o[0];return{value:u=n.valueCallback?n.valueCallback(u):u,rest:r.slice(i.length)}}),era:M({matchPatterns:{narrow:/^(b|a)/i,abbreviated:/^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,wide:/^(before christ|before common era|anno domini|common era)/i},defaultMatchWidth:"wide",parsePatterns:{any:[/^b/i,/^(a|c)/i]},defaultParseWidth:"any"}),quarter:M({matchPatterns:{narrow:/^[1234]/i,abbreviated:/^q[1234]/i,wide:/^[1234](th|st|nd|rd)? quarter/i},defaultMatchWidth:"wide",parsePatterns:{any:[/1/i,/2/i,/3/i,/4/i]},defaultParseWidth:"any",valueCallback:function(t){return t+1}}),month:M({matchPatterns:{narrow:/^[jfmasond]/i,abbreviated:/^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,wide:/^(january|february|march|april|may|june|july|august|september|october|november|december)/i},defaultMatchWidth:"wide",parsePatterns:{narrow:[/^j/i,/^f/i,/^m/i,/^a/i,/^m/i,/^j/i,/^j/i,/^a/i,/^s/i,/^o/i,/^n/i,/^d/i],any:[/^ja/i,/^f/i,/^mar/i,/^ap/i,/^may/i,/^jun/i,/^jul/i,/^au/i,/^s/i,/^o/i,/^n/i,/^d/i]},defaultParseWidth:"any"}),day:M({matchPatterns:{narrow:/^[smtwf]/i,short:/^(su|mo|tu|we|th|fr|sa)/i,abbreviated:/^(sun|mon|tue|wed|thu|fri|sat)/i,wide:/^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i},defaultMatchWidth:"wide",parsePatterns:{narrow:[/^s/i,/^m/i,/^t/i,/^w/i,/^t/i,/^f/i,/^s/i],any:[/^su/i,/^m/i,/^tu/i,/^w/i,/^th/i,/^f/i,/^sa/i]},defaultParseWidth:"any"}),dayPeriod:M({matchPatterns:{narrow:/^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,any:/^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i},defaultMatchWidth:"any",parsePatterns:{any:{am:/^a/i,pm:/^p/i,midnight:/^mi/i,noon:/^no/i,morning:/morning/i,afternoon:/afternoon/i,evening:/evening/i,night:/night/i}},defaultParseWidth:"any"})},options:{weekStartsOn:0,firstWeekContainsDate:1}};function U(t,n){r(2,arguments);var a=e(n);return u(t,-a)}function Y(t,e){for(var r=t<0?"-":"",n=Math.abs(t).toString();n.length0?r:1-r;return Y("yy"===e?n%100:n,e.length)},N=function(t,e){var r=t.getUTCMonth();return"M"===e?String(r+1):Y(r+1,2)},q=function(t,e){return Y(t.getUTCDate(),e.length)},P=function(t,e){return Y(t.getUTCHours()%12||12,e.length)},E=function(t,e){return Y(t.getUTCHours(),e.length)},H=function(t,e){return Y(t.getUTCMinutes(),e.length)},O=function(t,e){return Y(t.getUTCSeconds(),e.length)},W=function(t,e){var r=e.length,n=t.getUTCMilliseconds();return Y(Math.floor(n*Math.pow(10,r-3)),e.length)};function F(t){r(1,arguments);var e=1,a=n(t),i=a.getUTCDay(),o=(i=o.getTime()?a+1:e.getTime()>=s.getTime()?a:a-1}function Q(t){r(1,arguments);var e=L(t),n=new Date(0);n.setUTCFullYear(e,0,4),n.setUTCHours(0,0,0,0);var a=F(n);return a}function R(t){r(1,arguments);var e=n(t),a=F(e).getTime()-Q(e).getTime();return Math.round(a/6048e5)+1}function X(t,a){r(1,arguments);var i=a||{},o=i.locale,u=o&&o.options&&o.options.weekStartsOn,s=null==u?0:e(u),c=null==i.weekStartsOn?s:e(i.weekStartsOn);if(!(c>=0&&c<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");var d=n(t),l=d.getUTCDay(),f=(l=1&&l<=7))throw new RangeError("firstWeekContainsDate must be between 1 and 7 inclusively");var f=new Date(0);f.setUTCFullYear(o+1,0,l),f.setUTCHours(0,0,0,0);var h=X(f,a),m=new Date(0);m.setUTCFullYear(o,0,l),m.setUTCHours(0,0,0,0);var w=X(m,a);return i.getTime()>=h.getTime()?o+1:i.getTime()>=w.getTime()?o:o-1}function B(t,n){r(1,arguments);var a=n||{},i=a.locale,o=i&&i.options&&i.options.firstWeekContainsDate,u=null==o?1:e(o),s=null==a.firstWeekContainsDate?u:e(a.firstWeekContainsDate),c=G(t,n),d=new Date(0);d.setUTCFullYear(c,0,s),d.setUTCHours(0,0,0,0);var l=X(d,n);return l}function I(t,e){r(1,arguments);var a=n(t),i=X(a,e).getTime()-B(a,e).getTime();return Math.round(i/6048e5)+1}var z="midnight",j="noon",A="morning",Z="afternoon",K="evening",$="night",_={G:function(t,e,r){var n=t.getUTCFullYear()>0?1:0;switch(e){case"G":case"GG":case"GGG":return r.era(n,{width:"abbreviated"});case"GGGGG":return r.era(n,{width:"narrow"});case"GGGG":default:return r.era(n,{width:"wide"})}},y:function(t,e,r){if("yo"===e){var n=t.getUTCFullYear(),a=n>0?n:1-n;return r.ordinalNumber(a,{unit:"year"})}return S(t,e)},Y:function(t,e,r,n){var a=G(t,n),i=a>0?a:1-a;return"YY"===e?Y(i%100,2):"Yo"===e?r.ordinalNumber(i,{unit:"year"}):Y(i,e.length)},R:function(t,e){return Y(L(t),e.length)},u:function(t,e){return Y(t.getUTCFullYear(),e.length)},Q:function(t,e,r){var n=Math.ceil((t.getUTCMonth()+1)/3);switch(e){case"Q":return String(n);case"QQ":return Y(n,2);case"Qo":return r.ordinalNumber(n,{unit:"quarter"});case"QQQ":return r.quarter(n,{width:"abbreviated",context:"formatting"});case"QQQQQ":return r.quarter(n,{width:"narrow",context:"formatting"});case"QQQQ":default:return r.quarter(n,{width:"wide",context:"formatting"})}},q:function(t,e,r){var n=Math.ceil((t.getUTCMonth()+1)/3);switch(e){case"q":return String(n);case"qq":return Y(n,2);case"qo":return r.ordinalNumber(n,{unit:"quarter"});case"qqq":return r.quarter(n,{width:"abbreviated",context:"standalone"});case"qqqqq":return r.quarter(n,{width:"narrow",context:"standalone"});case"qqqq":default:return r.quarter(n,{width:"wide",context:"standalone"})}},M:function(t,e,r){var n=t.getUTCMonth();switch(e){case"M":case"MM":return N(t,e);case"Mo":return r.ordinalNumber(n+1,{unit:"month"});case"MMM":return r.month(n,{width:"abbreviated",context:"formatting"});case"MMMMM":return r.month(n,{width:"narrow",context:"formatting"});case"MMMM":default:return r.month(n,{width:"wide",context:"formatting"})}},L:function(t,e,r){var n=t.getUTCMonth();switch(e){case"L":return String(n+1);case"LL":return Y(n+1,2);case"Lo":return r.ordinalNumber(n+1,{unit:"month"});case"LLL":return r.month(n,{width:"abbreviated",context:"standalone"});case"LLLLL":return r.month(n,{width:"narrow",context:"standalone"});case"LLLL":default:return r.month(n,{width:"wide",context:"standalone"})}},w:function(t,e,r,n){var a=I(t,n);return"wo"===e?r.ordinalNumber(a,{unit:"week"}):Y(a,e.length)},I:function(t,e,r){var n=R(t);return"Io"===e?r.ordinalNumber(n,{unit:"week"}):Y(n,e.length)},d:function(t,e,r){return"do"===e?r.ordinalNumber(t.getUTCDate(),{unit:"date"}):q(t,e)},D:function(t,e,a){var i=function(t){r(1,arguments);var e=n(t),a=e.getTime();e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0);var i=e.getTime(),o=a-i;return Math.floor(o/864e5)+1}(t);return"Do"===e?a.ordinalNumber(i,{unit:"dayOfYear"}):Y(i,e.length)},E:function(t,e,r){var n=t.getUTCDay();switch(e){case"E":case"EE":case"EEE":return r.day(n,{width:"abbreviated",context:"formatting"});case"EEEEE":return r.day(n,{width:"narrow",context:"formatting"});case"EEEEEE":return r.day(n,{width:"short",context:"formatting"});case"EEEE":default:return r.day(n,{width:"wide",context:"formatting"})}},e:function(t,e,r,n){var a=t.getUTCDay(),i=(a-n.weekStartsOn+8)%7||7;switch(e){case"e":return String(i);case"ee":return Y(i,2);case"eo":return r.ordinalNumber(i,{unit:"day"});case"eee":return r.day(a,{width:"abbreviated",context:"formatting"});case"eeeee":return r.day(a,{width:"narrow",context:"formatting"});case"eeeeee":return r.day(a,{width:"short",context:"formatting"});case"eeee":default:return r.day(a,{width:"wide",context:"formatting"})}},c:function(t,e,r,n){var a=t.getUTCDay(),i=(a-n.weekStartsOn+8)%7||7;switch(e){case"c":return String(i);case"cc":return Y(i,e.length);case"co":return r.ordinalNumber(i,{unit:"day"});case"ccc":return r.day(a,{width:"abbreviated",context:"standalone"});case"ccccc":return r.day(a,{width:"narrow",context:"standalone"});case"cccccc":return r.day(a,{width:"short",context:"standalone"});case"cccc":default:return r.day(a,{width:"wide",context:"standalone"})}},i:function(t,e,r){var n=t.getUTCDay(),a=0===n?7:n;switch(e){case"i":return String(a);case"ii":return Y(a,e.length);case"io":return r.ordinalNumber(a,{unit:"day"});case"iii":return r.day(n,{width:"abbreviated",context:"formatting"});case"iiiii":return r.day(n,{width:"narrow",context:"formatting"});case"iiiiii":return r.day(n,{width:"short",context:"formatting"});case"iiii":default:return r.day(n,{width:"wide",context:"formatting"})}},a:function(t,e,r){var n=t.getUTCHours()/12>=1?"pm":"am";switch(e){case"a":case"aa":case"aaa":return r.dayPeriod(n,{width:"abbreviated",context:"formatting"});case"aaaaa":return r.dayPeriod(n,{width:"narrow",context:"formatting"});case"aaaa":default:return r.dayPeriod(n,{width:"wide",context:"formatting"})}},b:function(t,e,r){var n,a=t.getUTCHours();switch(n=12===a?j:0===a?z:a/12>=1?"pm":"am",e){case"b":case"bb":case"bbb":return r.dayPeriod(n,{width:"abbreviated",context:"formatting"});case"bbbbb":return r.dayPeriod(n,{width:"narrow",context:"formatting"});case"bbbb":default:return r.dayPeriod(n,{width:"wide",context:"formatting"})}},B:function(t,e,r){var n,a=t.getUTCHours();switch(n=a>=17?K:a>=12?Z:a>=4?A:$,e){case"B":case"BB":case"BBB":return r.dayPeriod(n,{width:"abbreviated",context:"formatting"});case"BBBBB":return r.dayPeriod(n,{width:"narrow",context:"formatting"});case"BBBB":default:return r.dayPeriod(n,{width:"wide",context:"formatting"})}},h:function(t,e,r){if("ho"===e){var n=t.getUTCHours()%12;return 0===n&&(n=12),r.ordinalNumber(n,{unit:"hour"})}return P(t,e)},H:function(t,e,r){return"Ho"===e?r.ordinalNumber(t.getUTCHours(),{unit:"hour"}):E(t,e)},K:function(t,e,r){var n=t.getUTCHours()%12;return"Ko"===e?r.ordinalNumber(n,{unit:"hour"}):Y(n,e.length)},k:function(t,e,r){var n=t.getUTCHours();return 0===n&&(n=24),"ko"===e?r.ordinalNumber(n,{unit:"hour"}):Y(n,e.length)},m:function(t,e,r){return"mo"===e?r.ordinalNumber(t.getUTCMinutes(),{unit:"minute"}):H(t,e)},s:function(t,e,r){return"so"===e?r.ordinalNumber(t.getUTCSeconds(),{unit:"second"}):O(t,e)},S:function(t,e){return W(t,e)},X:function(t,e,r,n){var a=(n._originalDate||t).getTimezoneOffset();if(0===a)return"Z";switch(e){case"X":return V(a);case"XXXX":case"XX":return tt(a);case"XXXXX":case"XXX":default:return tt(a,":")}},x:function(t,e,r,n){var a=(n._originalDate||t).getTimezoneOffset();switch(e){case"x":return V(a);case"xxxx":case"xx":return tt(a);case"xxxxx":case"xxx":default:return tt(a,":")}},O:function(t,e,r,n){var a=(n._originalDate||t).getTimezoneOffset();switch(e){case"O":case"OO":case"OOO":return"GMT"+J(a,":");case"OOOO":default:return"GMT"+tt(a,":")}},z:function(t,e,r,n){var a=(n._originalDate||t).getTimezoneOffset();switch(e){case"z":case"zz":case"zzz":return"GMT"+J(a,":");case"zzzz":default:return"GMT"+tt(a,":")}},t:function(t,e,r,n){var a=n._originalDate||t;return Y(Math.floor(a.getTime()/1e3),e.length)},T:function(t,e,r,n){return Y((n._originalDate||t).getTime(),e.length)}};function J(t,e){var r=t>0?"-":"+",n=Math.abs(t),a=Math.floor(n/60),i=n%60;if(0===i)return r+String(a);var o=e||"";return r+String(a)+o+Y(i,2)}function V(t,e){return t%60==0?(t>0?"-":"+")+Y(Math.abs(t)/60,2):tt(t,e)}function tt(t,e){var r=e||"",n=t>0?"-":"+",a=Math.abs(t);return n+Y(Math.floor(a/60),2)+r+Y(a%60,2)}function et(t,e){switch(t){case"P":return e.date({width:"short"});case"PP":return e.date({width:"medium"});case"PPP":return e.date({width:"long"});case"PPPP":default:return e.date({width:"full"})}}function rt(t,e){switch(t){case"p":return e.time({width:"short"});case"pp":return e.time({width:"medium"});case"ppp":return e.time({width:"long"});case"pppp":default:return e.time({width:"full"})}}var nt={p:rt,P:function(t,e){var r,n=t.match(/(P+)(p+)?/),a=n[1],i=n[2];if(!i)return et(t,e);switch(a){case"P":r=e.dateTime({width:"short"});break;case"PP":r=e.dateTime({width:"medium"});break;case"PPP":r=e.dateTime({width:"long"});break;case"PPPP":default:r=e.dateTime({width:"full"})}return r.replace("{{date}}",et(a,e)).replace("{{time}}",rt(i,e))}},at=["D","DD"],it=["YY","YYYY"];function ot(t){return-1!==at.indexOf(t)}function ut(t){return-1!==it.indexOf(t)}function st(t){if("YYYY"===t)throw new RangeError("Use `yyyy` instead of `YYYY` for formatting years; see: https://git.io/fxCyr");if("YY"===t)throw new RangeError("Use `yy` instead of `YY` for formatting years; see: https://git.io/fxCyr");if("D"===t)throw new RangeError("Use `d` instead of `D` for formatting days of the month; see: https://git.io/fxCyr");if("DD"===t)throw new RangeError("Use `dd` instead of `DD` for formatting days of the month; see: https://git.io/fxCyr")}var ct=/[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g,dt=/P+p+|P+|p+|''|'(''|[^'])+('|$)|./g,lt=/^'([^]*?)'?$/,ft=/''/g,ht=/[a-zA-Z]/;function mt(t){return t.match(lt)[1].replace(ft,"'")}function wt(t,e){if(null==t)throw new TypeError("assign requires that input parameter not be null or undefined");for(var r in e=e||{})e.hasOwnProperty(r)&&(t[r]=e[r]);return t}function gt(t,a,i){r(2,arguments);var o=i||{},u=o.locale,s=u&&u.options&&u.options.weekStartsOn,c=null==s?0:e(s),d=null==o.weekStartsOn?c:e(o.weekStartsOn);if(!(d>=0&&d<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");var l=n(t),f=e(a),h=l.getUTCDay(),m=f%7,w=(m+7)%7,g=(w0,a=n?e:1-e;if(a<=50)r=t||100;else{var i=a+50;r=t+100*Math.floor(i/100)-(t>=i%100?100:0)}return n?r:1-r}var Zt=[31,28,31,30,31,30,31,31,30,31,30,31],Kt=[31,29,31,30,31,30,31,31,30,31,30,31];function $t(t){return t%400==0||t%4==0&&t%100!=0}var _t={G:{priority:140,parse:function(t,e,r,n){switch(e){case"G":case"GG":case"GGG":return r.era(t,{width:"abbreviated"})||r.era(t,{width:"narrow"});case"GGGGG":return r.era(t,{width:"narrow"});case"GGGG":default:return r.era(t,{width:"wide"})||r.era(t,{width:"abbreviated"})||r.era(t,{width:"narrow"})}},set:function(t,e,r,n){return e.era=r,t.setUTCFullYear(r,0,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["R","u","t","T"]},y:{priority:130,parse:function(t,e,r,n){var a=function(t){return{year:t,isTwoDigitYear:"yy"===e}};switch(e){case"y":return It(4,t,a);case"yo":return r.ordinalNumber(t,{unit:"year",valueCallback:a});default:return It(e.length,t,a)}},validate:function(t,e,r){return e.isTwoDigitYear||e.year>0},set:function(t,e,r,n){var a=t.getUTCFullYear();if(r.isTwoDigitYear){var i=At(r.year,a);return t.setUTCFullYear(i,0,1),t.setUTCHours(0,0,0,0),t}var o="era"in e&&1!==e.era?1-r.year:r.year;return t.setUTCFullYear(o,0,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","u","w","I","i","e","c","t","T"]},Y:{priority:130,parse:function(t,e,r,n){var a=function(t){return{year:t,isTwoDigitYear:"YY"===e}};switch(e){case"Y":return It(4,t,a);case"Yo":return r.ordinalNumber(t,{unit:"year",valueCallback:a});default:return It(e.length,t,a)}},validate:function(t,e,r){return e.isTwoDigitYear||e.year>0},set:function(t,e,r,n){var a=G(t,n);if(r.isTwoDigitYear){var i=At(r.year,a);return t.setUTCFullYear(i,0,n.firstWeekContainsDate),t.setUTCHours(0,0,0,0),X(t,n)}var o="era"in e&&1!==e.era?1-r.year:r.year;return t.setUTCFullYear(o,0,n.firstWeekContainsDate),t.setUTCHours(0,0,0,0),X(t,n)},incompatibleTokens:["y","R","u","Q","q","M","L","I","d","D","i","t","T"]},R:{priority:130,parse:function(t,e,r,n){return zt("R"===e?4:e.length,t)},set:function(t,e,r,n){var a=new Date(0);return a.setUTCFullYear(r,0,4),a.setUTCHours(0,0,0,0),F(a)},incompatibleTokens:["G","y","Y","u","Q","q","M","L","w","d","D","e","c","t","T"]},u:{priority:130,parse:function(t,e,r,n){return zt("u"===e?4:e.length,t)},set:function(t,e,r,n){return t.setUTCFullYear(r,0,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["G","y","Y","R","w","I","i","e","c","t","T"]},Q:{priority:120,parse:function(t,e,r,n){switch(e){case"Q":case"QQ":return It(e.length,t);case"Qo":return r.ordinalNumber(t,{unit:"quarter"});case"QQQ":return r.quarter(t,{width:"abbreviated",context:"formatting"})||r.quarter(t,{width:"narrow",context:"formatting"});case"QQQQQ":return r.quarter(t,{width:"narrow",context:"formatting"});case"QQQQ":default:return r.quarter(t,{width:"wide",context:"formatting"})||r.quarter(t,{width:"abbreviated",context:"formatting"})||r.quarter(t,{width:"narrow",context:"formatting"})}},validate:function(t,e,r){return e>=1&&e<=4},set:function(t,e,r,n){return t.setUTCMonth(3*(r-1),1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","M","L","w","I","d","D","i","e","c","t","T"]},q:{priority:120,parse:function(t,e,r,n){switch(e){case"q":case"qq":return It(e.length,t);case"qo":return r.ordinalNumber(t,{unit:"quarter"});case"qqq":return r.quarter(t,{width:"abbreviated",context:"standalone"})||r.quarter(t,{width:"narrow",context:"standalone"});case"qqqqq":return r.quarter(t,{width:"narrow",context:"standalone"});case"qqqq":default:return r.quarter(t,{width:"wide",context:"standalone"})||r.quarter(t,{width:"abbreviated",context:"standalone"})||r.quarter(t,{width:"narrow",context:"standalone"})}},validate:function(t,e,r){return e>=1&&e<=4},set:function(t,e,r,n){return t.setUTCMonth(3*(r-1),1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","Q","M","L","w","I","d","D","i","e","c","t","T"]},M:{priority:110,parse:function(t,e,r,n){var a=function(t){return t-1};switch(e){case"M":return Xt(vt,t,a);case"MM":return It(2,t,a);case"Mo":return r.ordinalNumber(t,{unit:"month",valueCallback:a});case"MMM":return r.month(t,{width:"abbreviated",context:"formatting"})||r.month(t,{width:"narrow",context:"formatting"});case"MMMMM":return r.month(t,{width:"narrow",context:"formatting"});case"MMMM":default:return r.month(t,{width:"wide",context:"formatting"})||r.month(t,{width:"abbreviated",context:"formatting"})||r.month(t,{width:"narrow",context:"formatting"})}},validate:function(t,e,r){return e>=0&&e<=11},set:function(t,e,r,n){return t.setUTCMonth(r,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","Q","L","w","I","D","i","e","c","t","T"]},L:{priority:110,parse:function(t,e,r,n){var a=function(t){return t-1};switch(e){case"L":return Xt(vt,t,a);case"LL":return It(2,t,a);case"Lo":return r.ordinalNumber(t,{unit:"month",valueCallback:a});case"LLL":return r.month(t,{width:"abbreviated",context:"standalone"})||r.month(t,{width:"narrow",context:"standalone"});case"LLLLL":return r.month(t,{width:"narrow",context:"standalone"});case"LLLL":default:return r.month(t,{width:"wide",context:"standalone"})||r.month(t,{width:"abbreviated",context:"standalone"})||r.month(t,{width:"narrow",context:"standalone"})}},validate:function(t,e,r){return e>=0&&e<=11},set:function(t,e,r,n){return t.setUTCMonth(r,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","Q","M","w","I","D","i","e","c","t","T"]},w:{priority:100,parse:function(t,e,r,n){switch(e){case"w":return Xt(pt,t);case"wo":return r.ordinalNumber(t,{unit:"week"});default:return It(e.length,t)}},validate:function(t,e,r){return e>=1&&e<=53},set:function(t,a,i,o){return X(function(t,a,i){r(2,arguments);var o=n(t),u=e(a),s=I(o,i)-u;return o.setUTCDate(o.getUTCDate()-7*s),o}(t,i,o),o)},incompatibleTokens:["y","R","u","q","Q","M","L","I","d","D","i","t","T"]},I:{priority:100,parse:function(t,e,r,n){switch(e){case"I":return Xt(pt,t);case"Io":return r.ordinalNumber(t,{unit:"week"});default:return It(e.length,t)}},validate:function(t,e,r){return e>=1&&e<=53},set:function(t,a,i,o){return F(function(t,a){r(2,arguments);var i=n(t),o=e(a),u=R(i)-o;return i.setUTCDate(i.getUTCDate()-7*u),i}(t,i,o),o)},incompatibleTokens:["y","Y","u","q","Q","M","L","w","d","D","e","c","t","T"]},d:{priority:90,parse:function(t,e,r,n){switch(e){case"d":return Xt(yt,t);case"do":return r.ordinalNumber(t,{unit:"date"});default:return It(e.length,t)}},validate:function(t,e,r){var n=$t(t.getUTCFullYear()),a=t.getUTCMonth();return n?e>=1&&e<=Kt[a]:e>=1&&e<=Zt[a]},set:function(t,e,r,n){return t.setUTCDate(r),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","Q","w","I","D","i","e","c","t","T"]},D:{priority:90,parse:function(t,e,r,n){switch(e){case"D":case"DD":return Xt(bt,t);case"Do":return r.ordinalNumber(t,{unit:"date"});default:return It(e.length,t)}},validate:function(t,e,r){return $t(t.getUTCFullYear())?e>=1&&e<=366:e>=1&&e<=365},set:function(t,e,r,n){return t.setUTCMonth(0,r),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","Q","M","L","w","I","d","E","i","e","c","t","T"]},E:{priority:90,parse:function(t,e,r,n){switch(e){case"E":case"EE":case"EEE":return r.day(t,{width:"abbreviated",context:"formatting"})||r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"});case"EEEEE":return r.day(t,{width:"narrow",context:"formatting"});case"EEEEEE":return r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"});case"EEEE":default:return r.day(t,{width:"wide",context:"formatting"})||r.day(t,{width:"abbreviated",context:"formatting"})||r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"})}},validate:function(t,e,r){return e>=0&&e<=6},set:function(t,e,r,n){return(t=gt(t,r,n)).setUTCHours(0,0,0,0),t},incompatibleTokens:["D","i","e","c","t","T"]},e:{priority:90,parse:function(t,e,r,n){var a=function(t){var e=7*Math.floor((t-1)/7);return(t+n.weekStartsOn+6)%7+e};switch(e){case"e":case"ee":return It(e.length,t,a);case"eo":return r.ordinalNumber(t,{unit:"day",valueCallback:a});case"eee":return r.day(t,{width:"abbreviated",context:"formatting"})||r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"});case"eeeee":return r.day(t,{width:"narrow",context:"formatting"});case"eeeeee":return r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"});case"eeee":default:return r.day(t,{width:"wide",context:"formatting"})||r.day(t,{width:"abbreviated",context:"formatting"})||r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"})}},validate:function(t,e,r){return e>=0&&e<=6},set:function(t,e,r,n){return(t=gt(t,r,n)).setUTCHours(0,0,0,0),t},incompatibleTokens:["y","R","u","q","Q","M","L","I","d","D","E","i","c","t","T"]},c:{priority:90,parse:function(t,e,r,n){var a=function(t){var e=7*Math.floor((t-1)/7);return(t+n.weekStartsOn+6)%7+e};switch(e){case"c":case"cc":return It(e.length,t,a);case"co":return r.ordinalNumber(t,{unit:"day",valueCallback:a});case"ccc":return r.day(t,{width:"abbreviated",context:"standalone"})||r.day(t,{width:"short",context:"standalone"})||r.day(t,{width:"narrow",context:"standalone"});case"ccccc":return r.day(t,{width:"narrow",context:"standalone"});case"cccccc":return r.day(t,{width:"short",context:"standalone"})||r.day(t,{width:"narrow",context:"standalone"});case"cccc":default:return r.day(t,{width:"wide",context:"standalone"})||r.day(t,{width:"abbreviated",context:"standalone"})||r.day(t,{width:"short",context:"standalone"})||r.day(t,{width:"narrow",context:"standalone"})}},validate:function(t,e,r){return e>=0&&e<=6},set:function(t,e,r,n){return(t=gt(t,r,n)).setUTCHours(0,0,0,0),t},incompatibleTokens:["y","R","u","q","Q","M","L","I","d","D","E","i","e","t","T"]},i:{priority:90,parse:function(t,e,r,n){var a=function(t){return 0===t?7:t};switch(e){case"i":case"ii":return It(e.length,t);case"io":return r.ordinalNumber(t,{unit:"day"});case"iii":return r.day(t,{width:"abbreviated",context:"formatting",valueCallback:a})||r.day(t,{width:"short",context:"formatting",valueCallback:a})||r.day(t,{width:"narrow",context:"formatting",valueCallback:a});case"iiiii":return r.day(t,{width:"narrow",context:"formatting",valueCallback:a});case"iiiiii":return r.day(t,{width:"short",context:"formatting",valueCallback:a})||r.day(t,{width:"narrow",context:"formatting",valueCallback:a});case"iiii":default:return r.day(t,{width:"wide",context:"formatting",valueCallback:a})||r.day(t,{width:"abbreviated",context:"formatting",valueCallback:a})||r.day(t,{width:"short",context:"formatting",valueCallback:a})||r.day(t,{width:"narrow",context:"formatting",valueCallback:a})}},validate:function(t,e,r){return e>=1&&e<=7},set:function(t,a,i,o){return(t=function(t,a){r(2,arguments);var i=e(a);i%7==0&&(i-=7);var o=1,u=n(t),s=u.getUTCDay(),c=i%7,d=(c+7)%7,l=(d=1&&e<=12},set:function(t,e,r,n){var a=t.getUTCHours()>=12;return a&&r<12?t.setUTCHours(r+12,0,0,0):a||12!==r?t.setUTCHours(r,0,0,0):t.setUTCHours(0,0,0,0),t},incompatibleTokens:["H","K","k","t","T"]},H:{priority:70,parse:function(t,e,r,n){switch(e){case"H":return Xt(Tt,t);case"Ho":return r.ordinalNumber(t,{unit:"hour"});default:return It(e.length,t)}},validate:function(t,e,r){return e>=0&&e<=23},set:function(t,e,r,n){return t.setUTCHours(r,0,0,0),t},incompatibleTokens:["a","b","h","K","k","t","T"]},K:{priority:70,parse:function(t,e,r,n){switch(e){case"K":return Xt(xt,t);case"Ko":return r.ordinalNumber(t,{unit:"hour"});default:return It(e.length,t)}},validate:function(t,e,r){return e>=0&&e<=11},set:function(t,e,r,n){return t.getUTCHours()>=12&&r<12?t.setUTCHours(r+12,0,0,0):t.setUTCHours(r,0,0,0),t},incompatibleTokens:["a","b","h","H","k","t","T"]},k:{priority:70,parse:function(t,e,r,n){switch(e){case"k":return Xt(Ct,t);case"ko":return r.ordinalNumber(t,{unit:"hour"});default:return It(e.length,t)}},validate:function(t,e,r){return e>=1&&e<=24},set:function(t,e,r,n){var a=r<=24?r%24:r;return t.setUTCHours(a,0,0,0),t},incompatibleTokens:["a","b","h","H","K","t","T"]},m:{priority:60,parse:function(t,e,r,n){switch(e){case"m":return Xt(Dt,t);case"mo":return r.ordinalNumber(t,{unit:"minute"});default:return It(e.length,t)}},validate:function(t,e,r){return e>=0&&e<=59},set:function(t,e,r,n){return t.setUTCMinutes(r,0,0),t},incompatibleTokens:["t","T"]},s:{priority:50,parse:function(t,e,r,n){switch(e){case"s":return Xt(kt,t);case"so":return r.ordinalNumber(t,{unit:"second"});default:return It(e.length,t)}},validate:function(t,e,r){return e>=0&&e<=59},set:function(t,e,r,n){return t.setUTCSeconds(r,0),t},incompatibleTokens:["t","T"]},S:{priority:30,parse:function(t,e,r,n){return It(e.length,t,(function(t){return Math.floor(t*Math.pow(10,3-e.length))}))},set:function(t,e,r,n){return t.setUTCMilliseconds(r),t},incompatibleTokens:["t","T"]},X:{priority:10,parse:function(t,e,r,n){switch(e){case"X":return Gt(Wt,t);case"XX":return Gt(Ft,t);case"XXXX":return Gt(Lt,t);case"XXXXX":return Gt(Rt,t);case"XXX":default:return Gt(Qt,t)}},set:function(t,e,r,n){return e.timestampIsSet?t:new Date(t.getTime()-r)},incompatibleTokens:["t","T","x"]},x:{priority:10,parse:function(t,e,r,n){switch(e){case"x":return Gt(Wt,t);case"xx":return Gt(Ft,t);case"xxxx":return Gt(Lt,t);case"xxxxx":return Gt(Rt,t);case"xxx":default:return Gt(Qt,t)}},set:function(t,e,r,n){return e.timestampIsSet?t:new Date(t.getTime()-r)},incompatibleTokens:["t","T","X"]},t:{priority:40,parse:function(t,e,r,n){return Bt(t)},set:function(t,e,r,n){return[new Date(1e3*r),{timestampIsSet:!0}]},incompatibleTokens:"*"},T:{priority:20,parse:function(t,e,r,n){return Bt(t)},set:function(t,e,r,n){return[new Date(r),{timestampIsSet:!0}]},incompatibleTokens:"*"}},Jt=/[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g,Vt=/P+p+|P+|p+|''|'(''|[^'])+('|$)|./g,te=/^'([^]*?)'?$/,ee=/''/g,re=/\S/,ne=/[a-zA-Z]/;function ae(t,e){if(e.timestampIsSet)return t;var r=new Date(0);return r.setFullYear(t.getUTCFullYear(),t.getUTCMonth(),t.getUTCDate()),r.setHours(t.getUTCHours(),t.getUTCMinutes(),t.getUTCSeconds(),t.getUTCMilliseconds()),r}function ie(t){return t.match(te)[1].replace(ee,"'")}var oe={dateTimeDelimiter:/[T ]/,timeZoneDelimiter:/[Z ]/i,timezone:/([Z+-].*)$/},ue=/^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/,se=/^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/,ce=/^([+-])(\d{2})(?::?(\d{2}))?$/;function de(t){var e,r={},n=t.split(oe.dateTimeDelimiter);if(/:/.test(n[0])?(r.date=null,e=n[0]):(r.date=n[0],e=n[1],oe.timeZoneDelimiter.test(r.date)&&(r.date=t.split(oe.timeZoneDelimiter)[0],e=t.substr(r.date.length,t.length))),e){var a=oe.timezone.exec(e);a?(r.time=e.replace(a[1],""),r.timezone=a[1]):r.time=e}return r}function le(t,e){var r=new RegExp("^(?:(\\d{4}|[+-]\\d{"+(4+e)+"})|(\\d{2}|[+-]\\d{"+(2+e)+"})$)"),n=t.match(r);if(!n)return{year:null};var a=n[1]&&parseInt(n[1]),i=n[2]&&parseInt(n[2]);return{year:null==i?a:100*i,restDateString:t.slice((n[1]||n[2]).length)}}function fe(t,e){if(null===e)return null;var r=t.match(ue);if(!r)return null;var n=!!r[4],a=he(r[1]),i=he(r[2])-1,o=he(r[3]),u=he(r[4]),s=he(r[5])-1;if(n)return function(t,e,r){return e>=1&&e<=53&&r>=0&&r<=6}(0,u,s)?function(t,e,r){var n=new Date(0);n.setUTCFullYear(t,0,4);var a=n.getUTCDay()||7,i=7*(e-1)+r+1-a;return n.setUTCDate(n.getUTCDate()+i),n}(e,u,s):new Date(NaN);var c=new Date(0);return function(t,e,r){return e>=0&&e<=11&&r>=1&&r<=(ve[e]||(ye(t)?29:28))}(e,i,o)&&function(t,e){return e>=1&&e<=(ye(t)?366:365)}(e,a)?(c.setUTCFullYear(e,i,Math.max(a,o)),c):new Date(NaN)}function he(t){return t?parseInt(t):1}function me(t){var e=t.match(se);if(!e)return null;var r=we(e[1]),n=we(e[2]),a=we(e[3]);return function(t,e,r){if(24===t)return 0===e&&0===r;return r>=0&&r<60&&e>=0&&e<60&&t>=0&&t<25}(r,n,a)?36e5*r+6e4*n+1e3*a:NaN}function we(t){return t&&parseFloat(t.replace(",","."))||0}function ge(t){if("Z"===t)return 0;var e=t.match(ce);if(!e)return 0;var r="+"===e[1]?-1:1,n=parseInt(e[2]),a=e[3]&&parseInt(e[3])||0;return function(t,e){return e>=0&&e<=59}(0,a)?r*(36e5*n+6e4*a):NaN}var ve=[31,null,31,30,31,30,31,31,30,31,30,31];function ye(t){return t%400==0||t%4==0&&t%100}var be={datetime:"MMM d, yyyy, h:mm:ss aaaa",millisecond:"h:mm:ss.SSS aaaa",second:"h:mm:ss aaaa",minute:"h:mm aaaa",hour:"ha",day:"MMM d",week:"PP",month:"MMM yyyy",quarter:"qqq - yyyy",year:"yyyy"};t._adapters._date.override({_id:"date-fns",formats:function(){return be},parse:function(a,i){if(t.helpers.isNullOrUndef(a))return null;var o=typeof a;return"number"===o||a instanceof Date?a=n(a):"string"===o&&(a="string"==typeof i?function(t,a,i,o){r(3,arguments);var u=String(t),s=String(a),d=o||{},l=d.locale||k;if(!l.match)throw new RangeError("locale must contain match property");var f=l.options&&l.options.firstWeekContainsDate,h=null==f?1:e(f),m=null==d.firstWeekContainsDate?h:e(d.firstWeekContainsDate);if(!(m>=1&&m<=7))throw new RangeError("firstWeekContainsDate must be between 1 and 7 inclusively");var w=l.options&&l.options.weekStartsOn,g=null==w?0:e(w),v=null==d.weekStartsOn?g:e(d.weekStartsOn);if(!(v>=0&&v<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");if(""===s)return""===u?n(i):new Date(NaN);var y,b={firstWeekContainsDate:m,weekStartsOn:v,locale:l},p=[{priority:10,set:ae,index:0}],T=s.match(Vt).map((function(t){var e=t[0];return"p"===e||"P"===e?(0,nt[e])(t,l.formatLong,b):t})).join("").match(Jt),C=[];for(y=0;y0&&re.test(u))return new Date(NaN);var E=p.map((function(t){return t.priority})).sort((function(t,e){return e-t})).filter((function(t,e,r){return r.indexOf(t)===e})).map((function(t){return p.filter((function(e){return e.priority===t})).reverse()})).map((function(t){return t[0]})),H=n(i);if(isNaN(H))return new Date(NaN);var O=U(H,c(H)),W={};for(y=0;y0?w.setDate(m.getDate()+1):w.setDate(m.getDate()-1);var g=c(w)-d;g>0&&(d+=g)}return new Date(l+f+d)}(a,this.options)),h(a)?a.getTime():null},format:function(t,a){return function(t,a,i){r(2,arguments);var o=String(a),u=i||{},s=u.locale||k,d=s.options&&s.options.firstWeekContainsDate,l=null==d?1:e(d),f=null==u.firstWeekContainsDate?l:e(u.firstWeekContainsDate);if(!(f>=1&&f<=7))throw new RangeError("firstWeekContainsDate must be between 1 and 7 inclusively");var m=s.options&&s.options.weekStartsOn,w=null==m?0:e(m),g=null==u.weekStartsOn?w:e(u.weekStartsOn);if(!(g>=0&&g<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");if(!s.localize)throw new RangeError("locale must contain localize property");if(!s.formatLong)throw new RangeError("locale must contain formatLong property");var v=n(t);if(!h(v))throw new RangeError("Invalid time value");var y=c(v),b=U(v,y),p={firstWeekContainsDate:f,weekStartsOn:g,locale:s,_originalDate:v},T=o.match(dt).map((function(t){var e=t[0];return"p"===e||"P"===e?(0,nt[e])(t,s.formatLong,p):t})).join("").match(ct).map((function(t){if("''"===t)return"'";var e=t[0];if("'"===e)return mt(t);var r=_[e];if(r)return!u.useAdditionalWeekYearTokens&&ut(t)&&st(t),!u.useAdditionalDayOfYearTokens&&ot(t)&&st(t),r(b,t,s.localize,p);if(e.match(ht))throw new RangeError("Format string contains an unescaped latin alphabet character `"+e+"`");return t})).join("");return T}(t,a,this.options)},add:function(t,n,i){switch(i){case"millisecond":return u(t,n);case"second":return function(t,n){r(2,arguments);var a=e(n);return u(t,1e3*a)}(t,n);case"minute":return function(t,n){r(2,arguments);var a=e(n);return u(t,6e4*a)}(t,n);case"hour":return function(t,n){r(2,arguments);var a=e(n);return u(t,36e5*a)}(t,n);case"day":return a(t,n);case"week":return function(t,n){r(2,arguments);var i=e(n),o=7*i;return a(t,o)}(t,n);case"month":return o(t,n);case"quarter":return function(t,n){r(2,arguments);var a=e(n),i=3*a;return o(t,i)}(t,n);case"year":return function(t,n){r(2,arguments);var a=e(n);return o(t,12*a)}(t,n);default:return t}},diff:function(t,e,a){switch(a){case"millisecond":return v(t,e);case"second":return function(t,e){r(2,arguments);var n=v(t,e)/1e3;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"minute":return function(t,e){r(2,arguments);var n=v(t,e)/6e4;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"hour":return function(t,e){r(2,arguments);var n=v(t,e)/36e5;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"day":return g(t,e);case"week":return function(t,e){r(2,arguments);var n=g(t,e)/7;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"month":return y(t,e);case"quarter":return function(t,e){r(2,arguments);var n=y(t,e)/3;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"year":return function(t,e){r(2,arguments);var a=n(t),i=n(e),o=f(a,i),u=Math.abs(w(a,i));a.setFullYear(a.getFullYear()-o*u);var s=f(a,i)===-o,c=o*(u-s);return 0===c?0:c}(t,e);default:return 0}},startOf:function(t,e,a){switch(e){case"second":return function(t){r(1,arguments);var e=n(t);return e.setMilliseconds(0),e}(t);case"minute":return function(t){r(1,arguments);var e=n(t);return e.setSeconds(0,0),e}(t);case"hour":return function(t){r(1,arguments);var e=n(t);return e.setMinutes(0,0,0),e}(t);case"day":return d(t);case"week":return s(t);case"isoWeek":return s(t,{weekStartsOn:+a});case"month":return function(t){r(1,arguments);var e=n(t);return e.setDate(1),e.setHours(0,0,0,0),e}(t);case"quarter":return function(t){r(1,arguments);var e=n(t),a=e.getMonth(),i=a-a%3;return e.setMonth(i,1),e.setHours(0,0,0,0),e}(t);case"year":return function(t){r(1,arguments);var e=n(t),a=new Date(0);return a.setFullYear(e.getFullYear(),0,1),a.setHours(0,0,0,0),a}(t);default:return t}},endOf:function(t,a){switch(a){case"second":return function(t){r(1,arguments);var e=n(t);return e.setMilliseconds(999),e}(t);case"minute":return function(t){r(1,arguments);var e=n(t);return e.setSeconds(59,999),e}(t);case"hour":return function(t){r(1,arguments);var e=n(t);return e.setMinutes(59,59,999),e}(t);case"day":return function(t){r(1,arguments);var e=n(t);return e.setHours(23,59,59,999),e}(t);case"week":return function(t,a){r(1,arguments);var i=a||{},o=i.locale,u=o&&o.options&&o.options.weekStartsOn,s=null==u?0:e(u),c=null==i.weekStartsOn?s:e(i.weekStartsOn);if(!(c>=0&&c<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");var d=n(t),l=d.getDay(),f=6+(l1?"s":"")+" required, but only "+e.length+" present")}function n(t){r(1,arguments);var e=Object.prototype.toString.call(t);return t instanceof Date||"object"==typeof t&&"[object Date]"===e?new Date(t.getTime()):"number"==typeof t||"[object Number]"===e?new Date(t):("string"!=typeof t&&"[object String]"!==e||"undefined"==typeof console||(console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://git.io/fjule"),console.warn((new Error).stack)),new Date(NaN))}function a(t,a){r(2,arguments);var i=n(t),o=e(a);return isNaN(o)?new Date(NaN):o?(i.setDate(i.getDate()+o),i):i}function i(t,a){r(2,arguments);var i=n(t),o=e(a);if(isNaN(o))return new Date(NaN);if(!o)return i;var u=i.getDate(),s=new Date(i.getTime());s.setMonth(i.getMonth()+o+1,0);var c=s.getDate();return u>=c?s:(i.setFullYear(s.getFullYear(),s.getMonth(),u),i)}function o(t,a){r(2,arguments);var i=n(t).getTime(),o=e(a);return new Date(i+o)}var u=36e5;function s(t,a){r(1,arguments);var i=a||{},o=i.locale,u=o&&o.options&&o.options.weekStartsOn,s=null==u?0:e(u),c=null==i.weekStartsOn?s:e(i.weekStartsOn);if(!(c>=0&&c<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");var d=n(t),l=d.getDay(),f=(l0?1:o}function m(t){r(1,arguments);var e=n(t);return!isNaN(e)}function w(t,e){r(2,arguments);var a=n(t),i=n(e),o=a.getFullYear()-i.getFullYear(),u=a.getMonth()-i.getMonth();return 12*o+u}function g(t,e){r(2,arguments);var a=n(t),i=n(e);return a.getFullYear()-i.getFullYear()}function v(t,e){var r=t.getFullYear()-e.getFullYear()||t.getMonth()-e.getMonth()||t.getDate()-e.getDate()||t.getHours()-e.getHours()||t.getMinutes()-e.getMinutes()||t.getSeconds()-e.getSeconds()||t.getMilliseconds()-e.getMilliseconds();return r<0?-1:r>0?1:r}function y(t,e){r(2,arguments);var a=n(t),i=n(e),o=v(a,i),u=Math.abs(f(a,i));a.setDate(a.getDate()-o*u);var s=v(a,i)===-o,c=o*(u-s);return 0===c?0:c}function b(t,e){r(2,arguments);var a=n(t),i=n(e);return a.getTime()-i.getTime()}var T=36e5;function p(t){r(1,arguments);var e=n(t);return e.setHours(23,59,59,999),e}function C(t){r(1,arguments);var e=n(t),a=e.getMonth();return e.setFullYear(e.getFullYear(),a+1,0),e.setHours(23,59,59,999),e}function M(t){r(1,arguments);var e=n(t);return p(e).getTime()===C(e).getTime()}function D(t,e){r(2,arguments);var a,i=n(t),o=n(e),u=h(i,o),s=Math.abs(w(i,o));if(s<1)a=0;else{1===i.getMonth()&&i.getDate()>27&&i.setDate(30),i.setMonth(i.getMonth()-u*s);var c=h(i,o)===-u;M(n(t))&&1===s&&1===h(t,o)&&(c=!1),a=u*(s-c)}return 0===a?0:a}var x={lessThanXSeconds:{one:"less than a second",other:"less than {{count}} seconds"},xSeconds:{one:"1 second",other:"{{count}} seconds"},halfAMinute:"half a minute",lessThanXMinutes:{one:"less than a minute",other:"less than {{count}} minutes"},xMinutes:{one:"1 minute",other:"{{count}} minutes"},aboutXHours:{one:"about 1 hour",other:"about {{count}} hours"},xHours:{one:"1 hour",other:"{{count}} hours"},xDays:{one:"1 day",other:"{{count}} days"},aboutXWeeks:{one:"about 1 week",other:"about {{count}} weeks"},xWeeks:{one:"1 week",other:"{{count}} weeks"},aboutXMonths:{one:"about 1 month",other:"about {{count}} months"},xMonths:{one:"1 month",other:"{{count}} months"},aboutXYears:{one:"about 1 year",other:"about {{count}} years"},xYears:{one:"1 year",other:"{{count}} years"},overXYears:{one:"over 1 year",other:"over {{count}} years"},almostXYears:{one:"almost 1 year",other:"almost {{count}} years"}};function k(t){return function(e){var r=e||{},n=r.width?String(r.width):t.defaultWidth;return t.formats[n]||t.formats[t.defaultWidth]}}var U={date:k({formats:{full:"EEEE, MMMM do, y",long:"MMMM do, y",medium:"MMM d, y",short:"MM/dd/yyyy"},defaultWidth:"full"}),time:k({formats:{full:"h:mm:ss a zzzz",long:"h:mm:ss a z",medium:"h:mm:ss a",short:"h:mm a"},defaultWidth:"full"}),dateTime:k({formats:{full:"{{date}} 'at' {{time}}",long:"{{date}} 'at' {{time}}",medium:"{{date}}, {{time}}",short:"{{date}}, {{time}}"},defaultWidth:"full"})},Y={lastWeek:"'last' eeee 'at' p",yesterday:"'yesterday at' p",today:"'today at' p",tomorrow:"'tomorrow at' p",nextWeek:"eeee 'at' p",other:"P"};function N(t){return function(e,r){var n,a=r||{};if("formatting"===(a.context?String(a.context):"standalone")&&t.formattingValues){var i=t.defaultFormattingWidth||t.defaultWidth,o=a.width?String(a.width):i;n=t.formattingValues[o]||t.formattingValues[i]}else{var u=t.defaultWidth,s=a.width?String(a.width):t.defaultWidth;n=t.values[s]||t.values[u]}return n[t.argumentCallback?t.argumentCallback(e):e]}}function S(t){return function(e,r){var n=String(e),a=r||{},i=a.width,o=i&&t.matchPatterns[i]||t.matchPatterns[t.defaultMatchWidth],u=n.match(o);if(!u)return null;var s,c=u[0],d=i&&t.parsePatterns[i]||t.parsePatterns[t.defaultParseWidth];return s="[object Array]"===Object.prototype.toString.call(d)?function(t,e){for(var r=0;r0?"in "+n:n+" ago":n},formatLong:U,formatRelative:function(t,e,r,n){return Y[t]},localize:{ordinalNumber:function(t,e){var r=Number(t),n=r%100;if(n>20||n<10)switch(n%10){case 1:return r+"st";case 2:return r+"nd";case 3:return r+"rd"}return r+"th"},era:N({values:{narrow:["B","A"],abbreviated:["BC","AD"],wide:["Before Christ","Anno Domini"]},defaultWidth:"wide"}),quarter:N({values:{narrow:["1","2","3","4"],abbreviated:["Q1","Q2","Q3","Q4"],wide:["1st quarter","2nd quarter","3rd quarter","4th quarter"]},defaultWidth:"wide",argumentCallback:function(t){return Number(t)-1}}),month:N({values:{narrow:["J","F","M","A","M","J","J","A","S","O","N","D"],abbreviated:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],wide:["January","February","March","April","May","June","July","August","September","October","November","December"]},defaultWidth:"wide"}),day:N({values:{narrow:["S","M","T","W","T","F","S"],short:["Su","Mo","Tu","We","Th","Fr","Sa"],abbreviated:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],wide:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]},defaultWidth:"wide"}),dayPeriod:N({values:{narrow:{am:"a",pm:"p",midnight:"mi",noon:"n",morning:"morning",afternoon:"afternoon",evening:"evening",night:"night"},abbreviated:{am:"AM",pm:"PM",midnight:"midnight",noon:"noon",morning:"morning",afternoon:"afternoon",evening:"evening",night:"night"},wide:{am:"a.m.",pm:"p.m.",midnight:"midnight",noon:"noon",morning:"morning",afternoon:"afternoon",evening:"evening",night:"night"}},defaultWidth:"wide",formattingValues:{narrow:{am:"a",pm:"p",midnight:"mi",noon:"n",morning:"in the morning",afternoon:"in the afternoon",evening:"in the evening",night:"at night"},abbreviated:{am:"AM",pm:"PM",midnight:"midnight",noon:"noon",morning:"in the morning",afternoon:"in the afternoon",evening:"in the evening",night:"at night"},wide:{am:"a.m.",pm:"p.m.",midnight:"midnight",noon:"noon",morning:"in the morning",afternoon:"in the afternoon",evening:"in the evening",night:"at night"}},defaultFormattingWidth:"wide"})},match:{ordinalNumber:(P={matchPattern:/^(\d+)(th|st|nd|rd)?/i,parsePattern:/\d+/i,valueCallback:function(t){return parseInt(t,10)}},function(t,e){var r=String(t),n=e||{},a=r.match(P.matchPattern);if(!a)return null;var i=a[0],o=r.match(P.parsePattern);if(!o)return null;var u=P.valueCallback?P.valueCallback(o[0]):o[0];return{value:u=n.valueCallback?n.valueCallback(u):u,rest:r.slice(i.length)}}),era:S({matchPatterns:{narrow:/^(b|a)/i,abbreviated:/^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,wide:/^(before christ|before common era|anno domini|common era)/i},defaultMatchWidth:"wide",parsePatterns:{any:[/^b/i,/^(a|c)/i]},defaultParseWidth:"any"}),quarter:S({matchPatterns:{narrow:/^[1234]/i,abbreviated:/^q[1234]/i,wide:/^[1234](th|st|nd|rd)? quarter/i},defaultMatchWidth:"wide",parsePatterns:{any:[/1/i,/2/i,/3/i,/4/i]},defaultParseWidth:"any",valueCallback:function(t){return t+1}}),month:S({matchPatterns:{narrow:/^[jfmasond]/i,abbreviated:/^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,wide:/^(january|february|march|april|may|june|july|august|september|october|november|december)/i},defaultMatchWidth:"wide",parsePatterns:{narrow:[/^j/i,/^f/i,/^m/i,/^a/i,/^m/i,/^j/i,/^j/i,/^a/i,/^s/i,/^o/i,/^n/i,/^d/i],any:[/^ja/i,/^f/i,/^mar/i,/^ap/i,/^may/i,/^jun/i,/^jul/i,/^au/i,/^s/i,/^o/i,/^n/i,/^d/i]},defaultParseWidth:"any"}),day:S({matchPatterns:{narrow:/^[smtwf]/i,short:/^(su|mo|tu|we|th|fr|sa)/i,abbreviated:/^(sun|mon|tue|wed|thu|fri|sat)/i,wide:/^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i},defaultMatchWidth:"wide",parsePatterns:{narrow:[/^s/i,/^m/i,/^t/i,/^w/i,/^t/i,/^f/i,/^s/i],any:[/^su/i,/^m/i,/^tu/i,/^w/i,/^th/i,/^f/i,/^sa/i]},defaultParseWidth:"any"}),dayPeriod:S({matchPatterns:{narrow:/^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,any:/^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i},defaultMatchWidth:"any",parsePatterns:{any:{am:/^a/i,pm:/^p/i,midnight:/^mi/i,noon:/^no/i,morning:/morning/i,afternoon:/afternoon/i,evening:/evening/i,night:/night/i}},defaultParseWidth:"any"})},options:{weekStartsOn:0,firstWeekContainsDate:1}};function H(t,n){r(2,arguments);var a=e(n);return o(t,-a)}function E(t,e){for(var r=t<0?"-":"",n=Math.abs(t).toString();n.length0?r:1-r;return E("yy"===e?n%100:n,e.length)},M:function(t,e){var r=t.getUTCMonth();return"M"===e?String(r+1):E(r+1,2)},d:function(t,e){return E(t.getUTCDate(),e.length)},a:function(t,e){var r=t.getUTCHours()/12>=1?"pm":"am";switch(e){case"a":case"aa":return r.toUpperCase();case"aaa":return r;case"aaaaa":return r[0];default:return"am"===r?"a.m.":"p.m."}},h:function(t,e){return E(t.getUTCHours()%12||12,e.length)},H:function(t,e){return E(t.getUTCHours(),e.length)},m:function(t,e){return E(t.getUTCMinutes(),e.length)},s:function(t,e){return E(t.getUTCSeconds(),e.length)},S:function(t,e){var r=e.length,n=t.getUTCMilliseconds();return E(Math.floor(n*Math.pow(10,r-3)),e.length)}},F=864e5;function W(t){r(1,arguments);var e=1,a=n(t),i=a.getUTCDay(),o=(i=o.getTime()?a+1:e.getTime()>=s.getTime()?a:a-1}function Q(t){r(1,arguments);var e=L(t),n=new Date(0);n.setUTCFullYear(e,0,4),n.setUTCHours(0,0,0,0);var a=W(n);return a}var R=6048e5;function I(t){r(1,arguments);var e=n(t),a=W(e).getTime()-Q(e).getTime();return Math.round(a/R)+1}function G(t,a){r(1,arguments);var i=a||{},o=i.locale,u=o&&o.options&&o.options.weekStartsOn,s=null==u?0:e(u),c=null==i.weekStartsOn?s:e(i.weekStartsOn);if(!(c>=0&&c<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");var d=n(t),l=d.getUTCDay(),f=(l=1&&l<=7))throw new RangeError("firstWeekContainsDate must be between 1 and 7 inclusively");var f=new Date(0);f.setUTCFullYear(o+1,0,l),f.setUTCHours(0,0,0,0);var h=G(f,a),m=new Date(0);m.setUTCFullYear(o,0,l),m.setUTCHours(0,0,0,0);var w=G(m,a);return i.getTime()>=h.getTime()?o+1:i.getTime()>=w.getTime()?o:o-1}function j(t,n){r(1,arguments);var a=n||{},i=a.locale,o=i&&i.options&&i.options.firstWeekContainsDate,u=null==o?1:e(o),s=null==a.firstWeekContainsDate?u:e(a.firstWeekContainsDate),c=X(t,n),d=new Date(0);d.setUTCFullYear(c,0,s),d.setUTCHours(0,0,0,0);var l=G(d,n);return l}var B=6048e5;function z(t,e){r(1,arguments);var a=n(t),i=G(a,e).getTime()-j(a,e).getTime();return Math.round(i/B)+1}var A="midnight",Z="noon",K="morning",$="afternoon",_="evening",J="night",V={G:function(t,e,r){var n=t.getUTCFullYear()>0?1:0;switch(e){case"G":case"GG":case"GGG":return r.era(n,{width:"abbreviated"});case"GGGGG":return r.era(n,{width:"narrow"});default:return r.era(n,{width:"wide"})}},y:function(t,e,r){if("yo"===e){var n=t.getUTCFullYear(),a=n>0?n:1-n;return r.ordinalNumber(a,{unit:"year"})}return O.y(t,e)},Y:function(t,e,r,n){var a=X(t,n),i=a>0?a:1-a;return"YY"===e?E(i%100,2):"Yo"===e?r.ordinalNumber(i,{unit:"year"}):E(i,e.length)},R:function(t,e){return E(L(t),e.length)},u:function(t,e){return E(t.getUTCFullYear(),e.length)},Q:function(t,e,r){var n=Math.ceil((t.getUTCMonth()+1)/3);switch(e){case"Q":return String(n);case"QQ":return E(n,2);case"Qo":return r.ordinalNumber(n,{unit:"quarter"});case"QQQ":return r.quarter(n,{width:"abbreviated",context:"formatting"});case"QQQQQ":return r.quarter(n,{width:"narrow",context:"formatting"});default:return r.quarter(n,{width:"wide",context:"formatting"})}},q:function(t,e,r){var n=Math.ceil((t.getUTCMonth()+1)/3);switch(e){case"q":return String(n);case"qq":return E(n,2);case"qo":return r.ordinalNumber(n,{unit:"quarter"});case"qqq":return r.quarter(n,{width:"abbreviated",context:"standalone"});case"qqqqq":return r.quarter(n,{width:"narrow",context:"standalone"});default:return r.quarter(n,{width:"wide",context:"standalone"})}},M:function(t,e,r){var n=t.getUTCMonth();switch(e){case"M":case"MM":return O.M(t,e);case"Mo":return r.ordinalNumber(n+1,{unit:"month"});case"MMM":return r.month(n,{width:"abbreviated",context:"formatting"});case"MMMMM":return r.month(n,{width:"narrow",context:"formatting"});default:return r.month(n,{width:"wide",context:"formatting"})}},L:function(t,e,r){var n=t.getUTCMonth();switch(e){case"L":return String(n+1);case"LL":return E(n+1,2);case"Lo":return r.ordinalNumber(n+1,{unit:"month"});case"LLL":return r.month(n,{width:"abbreviated",context:"standalone"});case"LLLLL":return r.month(n,{width:"narrow",context:"standalone"});default:return r.month(n,{width:"wide",context:"standalone"})}},w:function(t,e,r,n){var a=z(t,n);return"wo"===e?r.ordinalNumber(a,{unit:"week"}):E(a,e.length)},I:function(t,e,r){var n=I(t);return"Io"===e?r.ordinalNumber(n,{unit:"week"}):E(n,e.length)},d:function(t,e,r){return"do"===e?r.ordinalNumber(t.getUTCDate(),{unit:"date"}):O.d(t,e)},D:function(t,e,a){var i=function(t){r(1,arguments);var e=n(t),a=e.getTime();e.setUTCMonth(0,1),e.setUTCHours(0,0,0,0);var i=e.getTime(),o=a-i;return Math.floor(o/F)+1}(t);return"Do"===e?a.ordinalNumber(i,{unit:"dayOfYear"}):E(i,e.length)},E:function(t,e,r){var n=t.getUTCDay();switch(e){case"E":case"EE":case"EEE":return r.day(n,{width:"abbreviated",context:"formatting"});case"EEEEE":return r.day(n,{width:"narrow",context:"formatting"});case"EEEEEE":return r.day(n,{width:"short",context:"formatting"});default:return r.day(n,{width:"wide",context:"formatting"})}},e:function(t,e,r,n){var a=t.getUTCDay(),i=(a-n.weekStartsOn+8)%7||7;switch(e){case"e":return String(i);case"ee":return E(i,2);case"eo":return r.ordinalNumber(i,{unit:"day"});case"eee":return r.day(a,{width:"abbreviated",context:"formatting"});case"eeeee":return r.day(a,{width:"narrow",context:"formatting"});case"eeeeee":return r.day(a,{width:"short",context:"formatting"});default:return r.day(a,{width:"wide",context:"formatting"})}},c:function(t,e,r,n){var a=t.getUTCDay(),i=(a-n.weekStartsOn+8)%7||7;switch(e){case"c":return String(i);case"cc":return E(i,e.length);case"co":return r.ordinalNumber(i,{unit:"day"});case"ccc":return r.day(a,{width:"abbreviated",context:"standalone"});case"ccccc":return r.day(a,{width:"narrow",context:"standalone"});case"cccccc":return r.day(a,{width:"short",context:"standalone"});default:return r.day(a,{width:"wide",context:"standalone"})}},i:function(t,e,r){var n=t.getUTCDay(),a=0===n?7:n;switch(e){case"i":return String(a);case"ii":return E(a,e.length);case"io":return r.ordinalNumber(a,{unit:"day"});case"iii":return r.day(n,{width:"abbreviated",context:"formatting"});case"iiiii":return r.day(n,{width:"narrow",context:"formatting"});case"iiiiii":return r.day(n,{width:"short",context:"formatting"});default:return r.day(n,{width:"wide",context:"formatting"})}},a:function(t,e,r){var n=t.getUTCHours()/12>=1?"pm":"am";switch(e){case"a":case"aa":return r.dayPeriod(n,{width:"abbreviated",context:"formatting"});case"aaa":return r.dayPeriod(n,{width:"abbreviated",context:"formatting"}).toLowerCase();case"aaaaa":return r.dayPeriod(n,{width:"narrow",context:"formatting"});default:return r.dayPeriod(n,{width:"wide",context:"formatting"})}},b:function(t,e,r){var n,a=t.getUTCHours();switch(n=12===a?Z:0===a?A:a/12>=1?"pm":"am",e){case"b":case"bb":return r.dayPeriod(n,{width:"abbreviated",context:"formatting"});case"bbb":return r.dayPeriod(n,{width:"abbreviated",context:"formatting"}).toLowerCase();case"bbbbb":return r.dayPeriod(n,{width:"narrow",context:"formatting"});default:return r.dayPeriod(n,{width:"wide",context:"formatting"})}},B:function(t,e,r){var n,a=t.getUTCHours();switch(n=a>=17?_:a>=12?$:a>=4?K:J,e){case"B":case"BB":case"BBB":return r.dayPeriod(n,{width:"abbreviated",context:"formatting"});case"BBBBB":return r.dayPeriod(n,{width:"narrow",context:"formatting"});default:return r.dayPeriod(n,{width:"wide",context:"formatting"})}},h:function(t,e,r){if("ho"===e){var n=t.getUTCHours()%12;return 0===n&&(n=12),r.ordinalNumber(n,{unit:"hour"})}return O.h(t,e)},H:function(t,e,r){return"Ho"===e?r.ordinalNumber(t.getUTCHours(),{unit:"hour"}):O.H(t,e)},K:function(t,e,r){var n=t.getUTCHours()%12;return"Ko"===e?r.ordinalNumber(n,{unit:"hour"}):E(n,e.length)},k:function(t,e,r){var n=t.getUTCHours();return 0===n&&(n=24),"ko"===e?r.ordinalNumber(n,{unit:"hour"}):E(n,e.length)},m:function(t,e,r){return"mo"===e?r.ordinalNumber(t.getUTCMinutes(),{unit:"minute"}):O.m(t,e)},s:function(t,e,r){return"so"===e?r.ordinalNumber(t.getUTCSeconds(),{unit:"second"}):O.s(t,e)},S:function(t,e){return O.S(t,e)},X:function(t,e,r,n){var a=(n._originalDate||t).getTimezoneOffset();if(0===a)return"Z";switch(e){case"X":return et(a);case"XXXX":case"XX":return rt(a);default:return rt(a,":")}},x:function(t,e,r,n){var a=(n._originalDate||t).getTimezoneOffset();switch(e){case"x":return et(a);case"xxxx":case"xx":return rt(a);default:return rt(a,":")}},O:function(t,e,r,n){var a=(n._originalDate||t).getTimezoneOffset();switch(e){case"O":case"OO":case"OOO":return"GMT"+tt(a,":");default:return"GMT"+rt(a,":")}},z:function(t,e,r,n){var a=(n._originalDate||t).getTimezoneOffset();switch(e){case"z":case"zz":case"zzz":return"GMT"+tt(a,":");default:return"GMT"+rt(a,":")}},t:function(t,e,r,n){var a=n._originalDate||t;return E(Math.floor(a.getTime()/1e3),e.length)},T:function(t,e,r,n){return E((n._originalDate||t).getTime(),e.length)}};function tt(t,e){var r=t>0?"-":"+",n=Math.abs(t),a=Math.floor(n/60),i=n%60;if(0===i)return r+String(a);var o=e||"";return r+String(a)+o+E(i,2)}function et(t,e){return t%60==0?(t>0?"-":"+")+E(Math.abs(t)/60,2):rt(t,e)}function rt(t,e){var r=e||"",n=t>0?"-":"+",a=Math.abs(t);return n+E(Math.floor(a/60),2)+r+E(a%60,2)}var nt=V;function at(t,e){switch(t){case"P":return e.date({width:"short"});case"PP":return e.date({width:"medium"});case"PPP":return e.date({width:"long"});default:return e.date({width:"full"})}}function it(t,e){switch(t){case"p":return e.time({width:"short"});case"pp":return e.time({width:"medium"});case"ppp":return e.time({width:"long"});default:return e.time({width:"full"})}}var ot={p:it,P:function(t,e){var r,n=t.match(/(P+)(p+)?/),a=n[1],i=n[2];if(!i)return at(t,e);switch(a){case"P":r=e.dateTime({width:"short"});break;case"PP":r=e.dateTime({width:"medium"});break;case"PPP":r=e.dateTime({width:"long"});break;default:r=e.dateTime({width:"full"})}return r.replace("{{date}}",at(a,e)).replace("{{time}}",it(i,e))}},ut=ot,st=["D","DD"],ct=["YY","YYYY"];function dt(t){return-1!==st.indexOf(t)}function lt(t){return-1!==ct.indexOf(t)}function ft(t,e,r){if("YYYY"===t)throw new RangeError("Use `yyyy` instead of `YYYY` (in `".concat(e,"`) for formatting years to the input `").concat(r,"`; see: https://git.io/fxCyr"));if("YY"===t)throw new RangeError("Use `yy` instead of `YY` (in `".concat(e,"`) for formatting years to the input `").concat(r,"`; see: https://git.io/fxCyr"));if("D"===t)throw new RangeError("Use `d` instead of `D` (in `".concat(e,"`) for formatting days of the month to the input `").concat(r,"`; see: https://git.io/fxCyr"));if("DD"===t)throw new RangeError("Use `dd` instead of `DD` (in `".concat(e,"`) for formatting days of the month to the input `").concat(r,"`; see: https://git.io/fxCyr"))}var ht=/[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g,mt=/P+p+|P+|p+|''|'(''|[^'])+('|$)|./g,wt=/^'([^]*?)'?$/,gt=/''/g,vt=/[a-zA-Z]/;function yt(t){return t.match(wt)[1].replace(gt,"'")}function bt(t,e){if(null==t)throw new TypeError("assign requires that input parameter not be null or undefined");for(var r in e=e||{})e.hasOwnProperty(r)&&(t[r]=e[r]);return t}function Tt(t,a,i){r(2,arguments);var o=i||{},u=o.locale,s=u&&u.options&&u.options.weekStartsOn,c=null==s?0:e(s),d=null==o.weekStartsOn?c:e(o.weekStartsOn);if(!(d>=0&&d<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");var l=n(t),f=e(a),h=l.getUTCDay(),m=f%7,w=(m+7)%7,g=(w0,a=n?e:1-e;if(a<=50)r=t||100;else{var i=a+50;r=t+100*Math.floor(i/100)-(t>=i%100?100:0)}return n?r:1-r}var Jt=[31,28,31,30,31,30,31,31,30,31,30,31],Vt=[31,29,31,30,31,30,31,31,30,31,30,31];function te(t){return t%400==0||t%4==0&&t%100!=0}var ee={G:{priority:140,parse:function(t,e,r,n){switch(e){case"G":case"GG":case"GGG":return r.era(t,{width:"abbreviated"})||r.era(t,{width:"narrow"});case"GGGGG":return r.era(t,{width:"narrow"});default:return r.era(t,{width:"wide"})||r.era(t,{width:"abbreviated"})||r.era(t,{width:"narrow"})}},set:function(t,e,r,n){return e.era=r,t.setUTCFullYear(r,0,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["R","u","t","T"]},y:{priority:130,parse:function(t,e,r,n){var a=function(t){return{year:t,isTwoDigitYear:"yy"===e}};switch(e){case"y":return Zt(4,t,a);case"yo":return r.ordinalNumber(t,{unit:"year",valueCallback:a});default:return Zt(e.length,t,a)}},validate:function(t,e,r){return e.isTwoDigitYear||e.year>0},set:function(t,e,r,n){var a=t.getUTCFullYear();if(r.isTwoDigitYear){var i=_t(r.year,a);return t.setUTCFullYear(i,0,1),t.setUTCHours(0,0,0,0),t}var o="era"in e&&1!==e.era?1-r.year:r.year;return t.setUTCFullYear(o,0,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","u","w","I","i","e","c","t","T"]},Y:{priority:130,parse:function(t,e,r,n){var a=function(t){return{year:t,isTwoDigitYear:"YY"===e}};switch(e){case"Y":return Zt(4,t,a);case"Yo":return r.ordinalNumber(t,{unit:"year",valueCallback:a});default:return Zt(e.length,t,a)}},validate:function(t,e,r){return e.isTwoDigitYear||e.year>0},set:function(t,e,r,n){var a=X(t,n);if(r.isTwoDigitYear){var i=_t(r.year,a);return t.setUTCFullYear(i,0,n.firstWeekContainsDate),t.setUTCHours(0,0,0,0),G(t,n)}var o="era"in e&&1!==e.era?1-r.year:r.year;return t.setUTCFullYear(o,0,n.firstWeekContainsDate),t.setUTCHours(0,0,0,0),G(t,n)},incompatibleTokens:["y","R","u","Q","q","M","L","I","d","D","i","t","T"]},R:{priority:130,parse:function(t,e,r,n){return Kt("R"===e?4:e.length,t)},set:function(t,e,r,n){var a=new Date(0);return a.setUTCFullYear(r,0,4),a.setUTCHours(0,0,0,0),W(a)},incompatibleTokens:["G","y","Y","u","Q","q","M","L","w","d","D","e","c","t","T"]},u:{priority:130,parse:function(t,e,r,n){return Kt("u"===e?4:e.length,t)},set:function(t,e,r,n){return t.setUTCFullYear(r,0,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["G","y","Y","R","w","I","i","e","c","t","T"]},Q:{priority:120,parse:function(t,e,r,n){switch(e){case"Q":case"QQ":return Zt(e.length,t);case"Qo":return r.ordinalNumber(t,{unit:"quarter"});case"QQQ":return r.quarter(t,{width:"abbreviated",context:"formatting"})||r.quarter(t,{width:"narrow",context:"formatting"});case"QQQQQ":return r.quarter(t,{width:"narrow",context:"formatting"});default:return r.quarter(t,{width:"wide",context:"formatting"})||r.quarter(t,{width:"abbreviated",context:"formatting"})||r.quarter(t,{width:"narrow",context:"formatting"})}},validate:function(t,e,r){return e>=1&&e<=4},set:function(t,e,r,n){return t.setUTCMonth(3*(r-1),1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","M","L","w","I","d","D","i","e","c","t","T"]},q:{priority:120,parse:function(t,e,r,n){switch(e){case"q":case"qq":return Zt(e.length,t);case"qo":return r.ordinalNumber(t,{unit:"quarter"});case"qqq":return r.quarter(t,{width:"abbreviated",context:"standalone"})||r.quarter(t,{width:"narrow",context:"standalone"});case"qqqqq":return r.quarter(t,{width:"narrow",context:"standalone"});default:return r.quarter(t,{width:"wide",context:"standalone"})||r.quarter(t,{width:"abbreviated",context:"standalone"})||r.quarter(t,{width:"narrow",context:"standalone"})}},validate:function(t,e,r){return e>=1&&e<=4},set:function(t,e,r,n){return t.setUTCMonth(3*(r-1),1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","Q","M","L","w","I","d","D","i","e","c","t","T"]},M:{priority:110,parse:function(t,e,r,n){var a=function(t){return t-1};switch(e){case"M":return Bt(pt,t,a);case"MM":return Zt(2,t,a);case"Mo":return r.ordinalNumber(t,{unit:"month",valueCallback:a});case"MMM":return r.month(t,{width:"abbreviated",context:"formatting"})||r.month(t,{width:"narrow",context:"formatting"});case"MMMMM":return r.month(t,{width:"narrow",context:"formatting"});default:return r.month(t,{width:"wide",context:"formatting"})||r.month(t,{width:"abbreviated",context:"formatting"})||r.month(t,{width:"narrow",context:"formatting"})}},validate:function(t,e,r){return e>=0&&e<=11},set:function(t,e,r,n){return t.setUTCMonth(r,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","Q","L","w","I","D","i","e","c","t","T"]},L:{priority:110,parse:function(t,e,r,n){var a=function(t){return t-1};switch(e){case"L":return Bt(pt,t,a);case"LL":return Zt(2,t,a);case"Lo":return r.ordinalNumber(t,{unit:"month",valueCallback:a});case"LLL":return r.month(t,{width:"abbreviated",context:"standalone"})||r.month(t,{width:"narrow",context:"standalone"});case"LLLLL":return r.month(t,{width:"narrow",context:"standalone"});default:return r.month(t,{width:"wide",context:"standalone"})||r.month(t,{width:"abbreviated",context:"standalone"})||r.month(t,{width:"narrow",context:"standalone"})}},validate:function(t,e,r){return e>=0&&e<=11},set:function(t,e,r,n){return t.setUTCMonth(r,1),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","Q","M","w","I","D","i","e","c","t","T"]},w:{priority:100,parse:function(t,e,r,n){switch(e){case"w":return Bt(Dt,t);case"wo":return r.ordinalNumber(t,{unit:"week"});default:return Zt(e.length,t)}},validate:function(t,e,r){return e>=1&&e<=53},set:function(t,a,i,o){return G(function(t,a,i){r(2,arguments);var o=n(t),u=e(a),s=z(o,i)-u;return o.setUTCDate(o.getUTCDate()-7*s),o}(t,i,o),o)},incompatibleTokens:["y","R","u","q","Q","M","L","I","d","D","i","t","T"]},I:{priority:100,parse:function(t,e,r,n){switch(e){case"I":return Bt(Dt,t);case"Io":return r.ordinalNumber(t,{unit:"week"});default:return Zt(e.length,t)}},validate:function(t,e,r){return e>=1&&e<=53},set:function(t,a,i,o){return W(function(t,a){r(2,arguments);var i=n(t),o=e(a),u=I(i)-o;return i.setUTCDate(i.getUTCDate()-7*u),i}(t,i,o),o)},incompatibleTokens:["y","Y","u","q","Q","M","L","w","d","D","e","c","t","T"]},d:{priority:90,subPriority:1,parse:function(t,e,r,n){switch(e){case"d":return Bt(Ct,t);case"do":return r.ordinalNumber(t,{unit:"date"});default:return Zt(e.length,t)}},validate:function(t,e,r){var n=te(t.getUTCFullYear()),a=t.getUTCMonth();return n?e>=1&&e<=Vt[a]:e>=1&&e<=Jt[a]},set:function(t,e,r,n){return t.setUTCDate(r),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","Q","w","I","D","i","e","c","t","T"]},D:{priority:90,subPriority:1,parse:function(t,e,r,n){switch(e){case"D":case"DD":return Bt(Mt,t);case"Do":return r.ordinalNumber(t,{unit:"date"});default:return Zt(e.length,t)}},validate:function(t,e,r){return te(t.getUTCFullYear())?e>=1&&e<=366:e>=1&&e<=365},set:function(t,e,r,n){return t.setUTCMonth(0,r),t.setUTCHours(0,0,0,0),t},incompatibleTokens:["Y","R","q","Q","M","L","w","I","d","E","i","e","c","t","T"]},E:{priority:90,parse:function(t,e,r,n){switch(e){case"E":case"EE":case"EEE":return r.day(t,{width:"abbreviated",context:"formatting"})||r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"});case"EEEEE":return r.day(t,{width:"narrow",context:"formatting"});case"EEEEEE":return r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"});default:return r.day(t,{width:"wide",context:"formatting"})||r.day(t,{width:"abbreviated",context:"formatting"})||r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"})}},validate:function(t,e,r){return e>=0&&e<=6},set:function(t,e,r,n){return(t=Tt(t,r,n)).setUTCHours(0,0,0,0),t},incompatibleTokens:["D","i","e","c","t","T"]},e:{priority:90,parse:function(t,e,r,n){var a=function(t){var e=7*Math.floor((t-1)/7);return(t+n.weekStartsOn+6)%7+e};switch(e){case"e":case"ee":return Zt(e.length,t,a);case"eo":return r.ordinalNumber(t,{unit:"day",valueCallback:a});case"eee":return r.day(t,{width:"abbreviated",context:"formatting"})||r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"});case"eeeee":return r.day(t,{width:"narrow",context:"formatting"});case"eeeeee":return r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"});default:return r.day(t,{width:"wide",context:"formatting"})||r.day(t,{width:"abbreviated",context:"formatting"})||r.day(t,{width:"short",context:"formatting"})||r.day(t,{width:"narrow",context:"formatting"})}},validate:function(t,e,r){return e>=0&&e<=6},set:function(t,e,r,n){return(t=Tt(t,r,n)).setUTCHours(0,0,0,0),t},incompatibleTokens:["y","R","u","q","Q","M","L","I","d","D","E","i","c","t","T"]},c:{priority:90,parse:function(t,e,r,n){var a=function(t){var e=7*Math.floor((t-1)/7);return(t+n.weekStartsOn+6)%7+e};switch(e){case"c":case"cc":return Zt(e.length,t,a);case"co":return r.ordinalNumber(t,{unit:"day",valueCallback:a});case"ccc":return r.day(t,{width:"abbreviated",context:"standalone"})||r.day(t,{width:"short",context:"standalone"})||r.day(t,{width:"narrow",context:"standalone"});case"ccccc":return r.day(t,{width:"narrow",context:"standalone"});case"cccccc":return r.day(t,{width:"short",context:"standalone"})||r.day(t,{width:"narrow",context:"standalone"});default:return r.day(t,{width:"wide",context:"standalone"})||r.day(t,{width:"abbreviated",context:"standalone"})||r.day(t,{width:"short",context:"standalone"})||r.day(t,{width:"narrow",context:"standalone"})}},validate:function(t,e,r){return e>=0&&e<=6},set:function(t,e,r,n){return(t=Tt(t,r,n)).setUTCHours(0,0,0,0),t},incompatibleTokens:["y","R","u","q","Q","M","L","I","d","D","E","i","e","t","T"]},i:{priority:90,parse:function(t,e,r,n){var a=function(t){return 0===t?7:t};switch(e){case"i":case"ii":return Zt(e.length,t);case"io":return r.ordinalNumber(t,{unit:"day"});case"iii":return r.day(t,{width:"abbreviated",context:"formatting",valueCallback:a})||r.day(t,{width:"short",context:"formatting",valueCallback:a})||r.day(t,{width:"narrow",context:"formatting",valueCallback:a});case"iiiii":return r.day(t,{width:"narrow",context:"formatting",valueCallback:a});case"iiiiii":return r.day(t,{width:"short",context:"formatting",valueCallback:a})||r.day(t,{width:"narrow",context:"formatting",valueCallback:a});default:return r.day(t,{width:"wide",context:"formatting",valueCallback:a})||r.day(t,{width:"abbreviated",context:"formatting",valueCallback:a})||r.day(t,{width:"short",context:"formatting",valueCallback:a})||r.day(t,{width:"narrow",context:"formatting",valueCallback:a})}},validate:function(t,e,r){return e>=1&&e<=7},set:function(t,a,i,o){return t=function(t,a){r(2,arguments);var i=e(a);i%7==0&&(i-=7);var o=1,u=n(t),s=u.getUTCDay(),c=((i%7+7)%7=1&&e<=12},set:function(t,e,r,n){var a=t.getUTCHours()>=12;return a&&r<12?t.setUTCHours(r+12,0,0,0):a||12!==r?t.setUTCHours(r,0,0,0):t.setUTCHours(0,0,0,0),t},incompatibleTokens:["H","K","k","t","T"]},H:{priority:70,parse:function(t,e,r,n){switch(e){case"H":return Bt(xt,t);case"Ho":return r.ordinalNumber(t,{unit:"hour"});default:return Zt(e.length,t)}},validate:function(t,e,r){return e>=0&&e<=23},set:function(t,e,r,n){return t.setUTCHours(r,0,0,0),t},incompatibleTokens:["a","b","h","K","k","t","T"]},K:{priority:70,parse:function(t,e,r,n){switch(e){case"K":return Bt(Ut,t);case"Ko":return r.ordinalNumber(t,{unit:"hour"});default:return Zt(e.length,t)}},validate:function(t,e,r){return e>=0&&e<=11},set:function(t,e,r,n){return t.getUTCHours()>=12&&r<12?t.setUTCHours(r+12,0,0,0):t.setUTCHours(r,0,0,0),t},incompatibleTokens:["a","b","h","H","k","t","T"]},k:{priority:70,parse:function(t,e,r,n){switch(e){case"k":return Bt(kt,t);case"ko":return r.ordinalNumber(t,{unit:"hour"});default:return Zt(e.length,t)}},validate:function(t,e,r){return e>=1&&e<=24},set:function(t,e,r,n){var a=r<=24?r%24:r;return t.setUTCHours(a,0,0,0),t},incompatibleTokens:["a","b","h","H","K","t","T"]},m:{priority:60,parse:function(t,e,r,n){switch(e){case"m":return Bt(Nt,t);case"mo":return r.ordinalNumber(t,{unit:"minute"});default:return Zt(e.length,t)}},validate:function(t,e,r){return e>=0&&e<=59},set:function(t,e,r,n){return t.setUTCMinutes(r,0,0),t},incompatibleTokens:["t","T"]},s:{priority:50,parse:function(t,e,r,n){switch(e){case"s":return Bt(St,t);case"so":return r.ordinalNumber(t,{unit:"second"});default:return Zt(e.length,t)}},validate:function(t,e,r){return e>=0&&e<=59},set:function(t,e,r,n){return t.setUTCSeconds(r,0),t},incompatibleTokens:["t","T"]},S:{priority:30,parse:function(t,e,r,n){return Zt(e.length,t,(function(t){return Math.floor(t*Math.pow(10,3-e.length))}))},set:function(t,e,r,n){return t.setUTCMilliseconds(r),t},incompatibleTokens:["t","T"]},X:{priority:10,parse:function(t,e,r,n){switch(e){case"X":return zt(Rt,t);case"XX":return zt(It,t);case"XXXX":return zt(Gt,t);case"XXXXX":return zt(jt,t);default:return zt(Xt,t)}},set:function(t,e,r,n){return e.timestampIsSet?t:new Date(t.getTime()-r)},incompatibleTokens:["t","T","x"]},x:{priority:10,parse:function(t,e,r,n){switch(e){case"x":return zt(Rt,t);case"xx":return zt(It,t);case"xxxx":return zt(Gt,t);case"xxxxx":return zt(jt,t);default:return zt(Xt,t)}},set:function(t,e,r,n){return e.timestampIsSet?t:new Date(t.getTime()-r)},incompatibleTokens:["t","T","X"]},t:{priority:40,parse:function(t,e,r,n){return At(t)},set:function(t,e,r,n){return[new Date(1e3*r),{timestampIsSet:!0}]},incompatibleTokens:"*"},T:{priority:20,parse:function(t,e,r,n){return At(t)},set:function(t,e,r,n){return[new Date(r),{timestampIsSet:!0}]},incompatibleTokens:"*"}},re=ee,ne=/[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g,ae=/P+p+|P+|p+|''|'(''|[^'])+('|$)|./g,ie=/^'([^]*?)'?$/,oe=/''/g,ue=/\S/,se=/[a-zA-Z]/;function ce(t,e){if(e.timestampIsSet)return t;var r=new Date(0);return r.setFullYear(t.getUTCFullYear(),t.getUTCMonth(),t.getUTCDate()),r.setHours(t.getUTCHours(),t.getUTCMinutes(),t.getUTCSeconds(),t.getUTCMilliseconds()),r}function de(t){return t.match(ie)[1].replace(oe,"'")}var le=36e5,fe={dateTimeDelimiter:/[T ]/,timeZoneDelimiter:/[Z ]/i,timezone:/([Z+-].*)$/},he=/^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/,me=/^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/,we=/^([+-])(\d{2})(?::?(\d{2}))?$/;function ge(t){var e,r={},n=t.split(fe.dateTimeDelimiter);if(n.length>2)return r;if(/:/.test(n[0])?(r.date=null,e=n[0]):(r.date=n[0],e=n[1],fe.timeZoneDelimiter.test(r.date)&&(r.date=t.split(fe.timeZoneDelimiter)[0],e=t.substr(r.date.length,t.length))),e){var a=fe.timezone.exec(e);a?(r.time=e.replace(a[1],""),r.timezone=a[1]):r.time=e}return r}function ve(t,e){var r=new RegExp("^(?:(\\d{4}|[+-]\\d{"+(4+e)+"})|(\\d{2}|[+-]\\d{"+(2+e)+"})$)"),n=t.match(r);if(!n)return{year:null};var a=n[1]&&parseInt(n[1]),i=n[2]&&parseInt(n[2]);return{year:null==i?a:100*i,restDateString:t.slice((n[1]||n[2]).length)}}function ye(t,e){if(null===e)return null;var r=t.match(he);if(!r)return null;var n=!!r[4],a=be(r[1]),i=be(r[2])-1,o=be(r[3]),u=be(r[4]),s=be(r[5])-1;if(n)return function(t,e,r){return e>=1&&e<=53&&r>=0&&r<=6}(0,u,s)?function(t,e,r){var n=new Date(0);n.setUTCFullYear(t,0,4);var a=n.getUTCDay()||7,i=7*(e-1)+r+1-a;return n.setUTCDate(n.getUTCDate()+i),n}(e,u,s):new Date(NaN);var c=new Date(0);return function(t,e,r){return e>=0&&e<=11&&r>=1&&r<=(Me[e]||(De(t)?29:28))}(e,i,o)&&function(t,e){return e>=1&&e<=(De(t)?366:365)}(e,a)?(c.setUTCFullYear(e,i,Math.max(a,o)),c):new Date(NaN)}function be(t){return t?parseInt(t):1}function Te(t){var e=t.match(me);if(!e)return null;var r=pe(e[1]),n=pe(e[2]),a=pe(e[3]);return function(t,e,r){if(24===t)return 0===e&&0===r;return r>=0&&r<60&&e>=0&&e<60&&t>=0&&t<25}(r,n,a)?r*le+6e4*n+1e3*a:NaN}function pe(t){return t&&parseFloat(t.replace(",","."))||0}function Ce(t){if("Z"===t)return 0;var e=t.match(we);if(!e)return 0;var r="+"===e[1]?-1:1,n=parseInt(e[2]),a=e[3]&&parseInt(e[3])||0;return function(t,e){return e>=0&&e<=59}(0,a)?r*(n*le+6e4*a):NaN}var Me=[31,null,31,30,31,30,31,31,30,31,30,31];function De(t){return t%400==0||t%4==0&&t%100}const xe={datetime:"MMM d, yyyy, h:mm:ss aaaa",millisecond:"h:mm:ss.SSS aaaa",second:"h:mm:ss aaaa",minute:"h:mm aaaa",hour:"ha",day:"MMM d",week:"PP",month:"MMM yyyy",quarter:"qqq - yyyy",year:"yyyy"};t._adapters._date.override({_id:"date-fns",formats:function(){return xe},parse:function(t,a){if(null==t)return null;const i=typeof t;return"number"===i||t instanceof Date?t=n(t):"string"===i&&(t="string"==typeof a?function(t,a,i,o){r(3,arguments);var u=String(t),s=String(a),d=o||{},l=d.locale||q;if(!l.match)throw new RangeError("locale must contain match property");var f=l.options&&l.options.firstWeekContainsDate,h=null==f?1:e(f),m=null==d.firstWeekContainsDate?h:e(d.firstWeekContainsDate);if(!(m>=1&&m<=7))throw new RangeError("firstWeekContainsDate must be between 1 and 7 inclusively");var w=l.options&&l.options.weekStartsOn,g=null==w?0:e(w),v=null==d.weekStartsOn?g:e(d.weekStartsOn);if(!(v>=0&&v<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");if(""===s)return""===u?n(i):new Date(NaN);var y,b={firstWeekContainsDate:m,weekStartsOn:v,locale:l},T=[{priority:10,subPriority:-1,set:ce,index:0}],p=s.match(ae).map((function(t){var e=t[0];return"p"===e||"P"===e?(0,ut[e])(t,l.formatLong,b):t})).join("").match(ne),C=[];for(y=0;y0&&ue.test(u))return new Date(NaN);var P=T.map((function(t){return t.priority})).sort((function(t,e){return e-t})).filter((function(t,e,r){return r.indexOf(t)===e})).map((function(t){return T.filter((function(e){return e.priority===t})).sort((function(t,e){return e.subPriority-t.subPriority}))})).map((function(t){return t[0]})),E=n(i);if(isNaN(E))return new Date(NaN);var O=H(E,c(E)),F={};for(y=0;y=1&&f<=7))throw new RangeError("firstWeekContainsDate must be between 1 and 7 inclusively");var h=s.options&&s.options.weekStartsOn,w=null==h?0:e(h),g=null==u.weekStartsOn?w:e(u.weekStartsOn);if(!(g>=0&&g<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");if(!s.localize)throw new RangeError("locale must contain localize property");if(!s.formatLong)throw new RangeError("locale must contain formatLong property");var v=n(t);if(!m(v))throw new RangeError("Invalid time value");var y=c(v),b=H(v,y),T={firstWeekContainsDate:f,weekStartsOn:g,locale:s,_originalDate:v},p=o.match(mt).map((function(t){var e=t[0];return"p"===e||"P"===e?(0,ut[e])(t,s.formatLong,T):t})).join("").match(ht).map((function(e){if("''"===e)return"'";var r=e[0];if("'"===r)return yt(e);var n=nt[r];if(n)return!u.useAdditionalWeekYearTokens&<(e)&&ft(e,a,t),!u.useAdditionalDayOfYearTokens&&dt(e)&&ft(e,a,t),n(b,e,s.localize,T);if(r.match(vt))throw new RangeError("Format string contains an unescaped latin alphabet character `"+r+"`");return e})).join("");return p}(t,a,this.options)},add:function(t,n,s){switch(s){case"millisecond":return o(t,n);case"second":return function(t,n){r(2,arguments);var a=e(n);return o(t,1e3*a)}(t,n);case"minute":return function(t,n){r(2,arguments);var a=e(n);return o(t,6e4*a)}(t,n);case"hour":return function(t,n){r(2,arguments);var a=e(n);return o(t,a*u)}(t,n);case"day":return a(t,n);case"week":return function(t,n){r(2,arguments);var i=e(n),o=7*i;return a(t,o)}(t,n);case"month":return i(t,n);case"quarter":return function(t,n){r(2,arguments);var a=e(n),o=3*a;return i(t,o)}(t,n);case"year":return function(t,n){r(2,arguments);var a=e(n);return i(t,12*a)}(t,n);default:return t}},diff:function(t,e,a){switch(a){case"millisecond":return b(t,e);case"second":return function(t,e){r(2,arguments);var n=b(t,e)/1e3;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"minute":return function(t,e){r(2,arguments);var n=b(t,e)/6e4;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"hour":return function(t,e){r(2,arguments);var n=b(t,e)/T;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"day":return y(t,e);case"week":return function(t,e){r(2,arguments);var n=y(t,e)/7;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"month":return D(t,e);case"quarter":return function(t,e){r(2,arguments);var n=D(t,e)/3;return n>0?Math.floor(n):Math.ceil(n)}(t,e);case"year":return function(t,e){r(2,arguments);var a=n(t),i=n(e),o=h(a,i),u=Math.abs(g(a,i));a.setFullYear("1584"),i.setFullYear("1584");var s=h(a,i)===-o,c=o*(u-s);return 0===c?0:c}(t,e);default:return 0}},startOf:function(t,e,a){switch(e){case"second":return function(t){r(1,arguments);var e=n(t);return e.setMilliseconds(0),e}(t);case"minute":return function(t){r(1,arguments);var e=n(t);return e.setSeconds(0,0),e}(t);case"hour":return function(t){r(1,arguments);var e=n(t);return e.setMinutes(0,0,0),e}(t);case"day":return d(t);case"week":return s(t);case"isoWeek":return s(t,{weekStartsOn:+a});case"month":return function(t){r(1,arguments);var e=n(t);return e.setDate(1),e.setHours(0,0,0,0),e}(t);case"quarter":return function(t){r(1,arguments);var e=n(t),a=e.getMonth(),i=a-a%3;return e.setMonth(i,1),e.setHours(0,0,0,0),e}(t);case"year":return function(t){r(1,arguments);var e=n(t),a=new Date(0);return a.setFullYear(e.getFullYear(),0,1),a.setHours(0,0,0,0),a}(t);default:return t}},endOf:function(t,a){switch(a){case"second":return function(t){r(1,arguments);var e=n(t);return e.setMilliseconds(999),e}(t);case"minute":return function(t){r(1,arguments);var e=n(t);return e.setSeconds(59,999),e}(t);case"hour":return function(t){r(1,arguments);var e=n(t);return e.setMinutes(59,59,999),e}(t);case"day":return p(t);case"week":return function(t,a){r(1,arguments);var i=a||{},o=i.locale,u=o&&o.options&&o.options.weekStartsOn,s=null==u?0:e(u),c=null==i.weekStartsOn?s:e(i.weekStartsOn);if(!(c>=0&&c<=6))throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");var d=n(t),l=d.getDay(),f=6+(l Date: Mon, 29 Sep 2025 14:31:40 +0200 Subject: [PATCH 4/4] Update chart.component.js update to use chart.js 3.9.1 instead of 3.0.0-beta --- www/ftui/components/chart/chart.component.js | 244 +++++++++++-------- 1 file changed, 141 insertions(+), 103 deletions(-) diff --git a/www/ftui/components/chart/chart.component.js b/www/ftui/components/chart/chart.component.js index 05b20a96..4993df47 100755 --- a/www/ftui/components/chart/chart.component.js +++ b/www/ftui/components/chart/chart.component.js @@ -1,77 +1,111 @@ /* * Chart component for FTUI version 3 -* -* Copyright (c) 2020 Mario Stephan -* Under MIT License (http://www.opensource.org/licenses/mit-license.php) -* -* https://github.com/knowthelist/ftui +* (patched for Chart.js v3.9.1) */ import { FtuiElement } from '../element.component.js'; import { FtuiChartData } from './chart-data.component.js'; import { fhemService } from '../../modules/ftui/fhem.service.js'; -import { Chart } from '../../modules/chart.js/chart.min.js'; import { dateFormat, getStylePropertyValue, isVisible } from '../../modules/ftui/ftui.helper.js'; + +/* UMD-Builds laden (Chart global auf window) */ +import '../../modules/chart.js/chart.min.js'; import '../../modules/chart.js/chartjs-adapter-date-fns.bundle.min.js'; +const { Chart } = window; + const HOUR = 3600 * 1000; -const DAY = 24 * 3600 * 1000; +const DAY = 24 * 3600 * 1000; + +/** Mappt eine CSS-Variable auf font.style ODER font.weight (Zahlen => weight) */ +function applyFontStyleOrWeight(fontObj, value) { + if (!value) return; + const v = String(value).trim(); + // typische Style-Werte + if (v === 'italic' || v === 'oblique') { + fontObj.style = v; + return; + } + // alles andere behandeln wir als Weight (normal, bold, 300..900, 500 etc.) + fontObj.weight = v; +} export class FtuiChart extends FtuiElement { constructor(properties) { - super(Object.assign(FtuiChart.properties, properties)); + // Globale Defaults (v3: color global, font.* unter defaults.font) + const baseFamily = getStylePropertyValue('--chart-font-family', this); + if (baseFamily) Chart.defaults.font.family = baseFamily; + + const baseStyleOrWeight = getStylePropertyValue('--chart-font-style', this); + applyFontStyleOrWeight(Chart.defaults.font, baseStyleOrWeight); + + const baseColor = getStylePropertyValue('--chart-text-color', this); + if (baseColor) Chart.defaults.color = baseColor; + this.configuration = { type: this.type, - data: { - datasets: [], - }, + data: { datasets: [] }, options: { - locale: window.ftuiApp ? ftuiApp.config.lang === 'de' ? 'de-DE' : 'en-US' : 'en-US', + locale: window.ftuiApp ? (ftuiApp.config.lang === 'de' ? 'de-DE' : 'en-US') : 'en-US', responsive: true, maintainAspectRatio: false, - title: { - padding: 0, - display: false, - text: '', - }, - legend: { - labels: { - usePointStyle: true, - boxWidth: 6, - padding: 8, - font: {}, - filter: item => item.text, - generateLabels: function (chart) { - const data = chart.data; - return Chart.helpers.isArray(data.datasets) ? data.datasets.map((dataset, i) => { - const values = dataset.data.map(i => i.y); - let resLabel = dataset.label; - if (resLabel && values && values.length) { - resLabel = resLabel.replace(/\$min/g, Math.min(...values)); - resLabel = resLabel.replace(/\$max/g, Math.max(...values)); - resLabel = resLabel.replace(/\$sum/g, values.reduce((a, b) => a + b)); - resLabel = resLabel.replace(/\$avg/g, values.reduce((a, b) => a + b) / values.length); - resLabel = resLabel.replace(/\$last/g, values[values.length - 1]); - } - return { - text: resLabel, - fillStyle: (!Chart.helpers.isArray(dataset.backgroundColor) ? dataset.backgroundColor : dataset.backgroundColor[0]), - hidden: !chart.isDatasetVisible(i), - lineCap: dataset.borderCapStyle, - lineDash: dataset.borderDash, - lineDashOffset: dataset.borderDashOffset, - lineJoin: dataset.borderJoinStyle, - lineWidth: dataset.borderWidth, - strokeStyle: dataset.borderColor, - pointStyle: dataset.pointStyle, - datasetIndex: i, - }; - }, this) : []; + animation: { duration: 300 }, + + /* v3: Plugins */ + plugins: { + title: { + padding: 0, + display: false, + text: '', + font: {} // size/style/weight setzen wir dynamisch in onStyleChanged() + }, + legend: { + labels: { + usePointStyle: true, + boxWidth: 6, + padding: 8, + font: {}, + filter: item => item.text, + generateLabels: (chart) => { + const data = chart.data; + return Array.isArray(data.datasets) ? data.datasets.map((dataset, i) => { + const values = (dataset.data || []).map(p => (p && typeof p === 'object' ? p.y : p)); + let resLabel = dataset.label; + if (resLabel && values && values.length) { + const sum = values.reduce((a, b) => a + (+b || 0), 0); + const avg = sum / values.length; + resLabel = resLabel.replace(/\$min/g, Math.min(...values)); + resLabel = resLabel.replace(/\$max/g, Math.max(...values)); + resLabel = resLabel.replace(/\$sum/g, sum); + resLabel = resLabel.replace(/\$avg/g, avg); + resLabel = resLabel.replace(/\$last/g, values[values.length - 1]); + } + const fill = Array.isArray(dataset.backgroundColor) + ? dataset.backgroundColor[0] + : dataset.backgroundColor; + return { + text: resLabel, + fillStyle: fill, + hidden: !chart.isDatasetVisible(i), + lineCap: dataset.borderCapStyle, + lineDash: dataset.borderDash, + lineDashOffset: dataset.borderDashOffset, + lineJoin: dataset.borderJoinStyle, + lineWidth: dataset.borderWidth, + strokeStyle: dataset.borderColor, + pointStyle: dataset.pointStyle, + datasetIndex: i, + }; + }) : []; + }, }, }, + tooltip: {} }, + + /* v3: Scales */ scales: { x: { display: !this.noscale && !this.noX, @@ -79,10 +113,17 @@ export class FtuiChart extends FtuiElement { stacked: this.stackedX, time: { parser: 'yyyy-MM-dd_HH:mm:ss', - displayFormats: { millisecond: 'HH:mm:ss.SSS', second: 'HH:mm:ss', minute: 'HH:mm', hour: 'HH:mm', day: 'd. MMM', month: 'MMMM' }, + displayFormats: { + millisecond: 'HH:mm:ss.SSS', + second: 'HH:mm:ss', + minute: 'HH:mm', + hour: 'HH:mm', + day: 'd. MMM', + month: 'MMMM' + }, tooltipFormat: 'd.MM.yyyy HH:mm:ss', }, - gridLines: {}, + grid: {}, ticks: { maxRotation: 0, autoSkip: true, @@ -94,11 +135,8 @@ export class FtuiChart extends FtuiElement { stacked: this.stackedY, display: !this.noscale && !this.noY, position: 'left', - scaleLabel: { - display: this.yLabel.length > 0, - labelString: this.yLabel, - }, - gridLines: {}, + title: { display: this.yLabel.length > 0, text: this.yLabel }, + grid: {}, ticks: { autoSkip: true, autoSkipPadding: 30, @@ -110,11 +148,8 @@ export class FtuiChart extends FtuiElement { stacked: this.stackedY1, display: (!this.noscale && !this.noY1), position: 'right', - scaleLabel: { - display: this.y1Label.length > 0, - labelString: this.y1Label, - }, - gridLines: {}, + title: { display: this.y1Label.length > 0, text: this.y1Label }, + grid: {}, ticks: { autoSkip: true, autoSkipPadding: 30, @@ -126,18 +161,9 @@ export class FtuiChart extends FtuiElement { }, }; - if (getStylePropertyValue('--chart-font-family', this)) { - Chart.defaults.font.family = getStylePropertyValue('--chart-font-family', this) - } - if (getStylePropertyValue('--chart-font-style', this)) { - Chart.defaults.font.style = getStylePropertyValue('--chart-font-style', this) - } - - Chart.defaults.font.color = getStylePropertyValue('--chart-text-color', this); - this.controlsElement = this.querySelector('ftui-chart-controls'); - this.chartContainer = this.shadowRoot.querySelector('#container'); - this.chartElement = this.shadowRoot.querySelector('#chart'); + this.chartContainer = this.shadowRoot.querySelector('#container'); + this.chartElement = this.shadowRoot.querySelector('#chart'); this.chart = new Chart(this.chartElement, this.configuration); @@ -145,28 +171,26 @@ export class FtuiChart extends FtuiElement { this.dataElements.forEach((dataElement, index) => { dataElement.index = index; this.configuration.data.datasets[index] = {}; - dataElement.addEventListener('ftuiDataChanged', data => this.onDataChanged(data)) + dataElement.addEventListener('ftuiDataChanged', data => this.onDataChanged(data)); }); if (this.controlsElement) { - this.controlsElement.addEventListener('ftuiForward', () => this.offset += 1); + this.controlsElement.addEventListener('ftuiForward', () => this.offset += 1); this.controlsElement.addEventListener('ftuiBackward', () => this.offset -= 1); ['hour', 'day', 'week', 'month', 'year', '24h', '30d'].forEach(unit => { this.controlsElement.addEventListener('ftuiUnit' + unit, () => this.unit = unit); }); } + this.chart.update(); this.onStyleChanged(); document.addEventListener('ftuiVisibilityChanged', () => this.refresh()); - fhemService.getReadingEvents('ftui-isDark').subscribe(() => this.onStyleChanged()); } connectedCallback() { - window.requestAnimationFrame(() => { - this.refresh(); - }) + window.requestAnimationFrame(() => this.refresh()); } template() { @@ -268,8 +292,8 @@ export class FtuiChart extends FtuiElement { const options = this.configuration.options; switch (name) { case 'title': - options.title.text = value; - options.title.display = (value && value.length > 0); + options.plugins.title.text = value; + options.plugins.title.display = (value && value.length > 0); this.chart.update(); break; case 'type': @@ -328,9 +352,9 @@ export class FtuiChart extends FtuiElement { this.dataElements.forEach(dataElement => { if (typeof dataElement.fetch === 'function') { dataElement.startDate = this.startDate; - dataElement.endDate = this.endDate; - dataElement.prefetch = (!dataElement.prefetch) ? this.prefetch : dataElement.prefetch; - dataElement.extend = (!dataElement.extend) ? this.extend : dataElement.extend; + dataElement.endDate = this.endDate; + dataElement.prefetch = (!dataElement.prefetch) ? this.prefetch : dataElement.prefetch; + dataElement.extend = (!dataElement.extend) ? this.extend : dataElement.extend; dataElement.fetch(); } }); @@ -341,12 +365,12 @@ export class FtuiChart extends FtuiElement { if (this.controlsElement) { this.controlsElement.unit = this.unit; this.controlsElement.startDate = this.startDate; - this.controlsElement.endDate = this.endDate; + this.controlsElement.endDate = this.endDate; } } onDataChanged(event) { - const dataElement = event.target + const dataElement = event.target; const dataset = {}; Object.keys(FtuiChartData.properties).forEach(property => { dataset[property] = dataElement[property]; @@ -356,44 +380,58 @@ export class FtuiChart extends FtuiElement { if (dataElement.yAxisID === 'y1') { this.hasY1Data = true; } + this.configuration.data.datasets[dataElement.index] = dataset; this.configuration.data.labels = dataElement.labels; + this.configuration.options.scales.x.min = this.startDate; this.configuration.options.scales.x.max = this.endDate; this.configuration.options.scales.y1.display = this.hasY1Data && !this.noY1; + dataElement.startDate = this.startDate; - dataElement.endDate = this.endDate; + dataElement.endDate = this.endDate; this.updateControls(); - // run chart update async - Promise.resolve().then(this.chart.update()); - // disable animation after first update + + // async & korrekt + Promise.resolve().then(() => this.chart.update()); + + // nach erstem Render Animation aus this.configuration.options.animation.duration = 0; } onStyleChanged() { const options = this.configuration.options; - options.font.color = getStylePropertyValue('--chart-text-color', this); - options.title.font.size = getStylePropertyValue('--chart-title-font-size', this) || 16; - options.title.font.style = getStylePropertyValue('--chart-title-font-style', this) || '500'; - options.title.font.color = getStylePropertyValue('--chart-title-color', this);// || getStylePropertyValue('--chart-text-color', this); + // Titel (v3: plugins.title) – size, color sowie style/weight korrekt setzen + options.plugins.title.font.size = getStylePropertyValue('--chart-title-font-size', this) || 16; + const titleStyleOrWeight = getStylePropertyValue('--chart-title-font-style', this) || 'normal'; + applyFontStyleOrWeight(options.plugins.title.font, titleStyleOrWeight); + options.plugins.title.color = getStylePropertyValue('--chart-title-color', this) + || getStylePropertyValue('--chart-text-color', this); - options.legend.labels.font.size = getStylePropertyValue('--chart-legend-font-size', this) || 13; - options.legend.labels.font.color = getStylePropertyValue('--chart-legend-color', this) || getStylePropertyValue('--chart-text-color', this); + // Legende (v3: plugins.legend.labels) + options.plugins.legend.labels.font.size = getStylePropertyValue('--chart-legend-font-size', this) || 13; + options.plugins.legend.labels.color = getStylePropertyValue('--chart-legend-color', this) + || getStylePropertyValue('--chart-text-color', this); - options.scales.x.gridLines.color = getStylePropertyValue('--chart-grid-line-color', this) || getStylePropertyValue('--dark-color', this); - options.scales.x.ticks.font.size = getStylePropertyValue('--chart-tick-font-size', this) || 11; + const gridColor = getStylePropertyValue('--chart-grid-line-color', this) + || getStylePropertyValue('--dark-color', this); + const tickSize = getStylePropertyValue('--chart-tick-font-size', this) || 11; - options.scales.y.gridLines.color = getStylePropertyValue('--chart-grid-line-color', this) || getStylePropertyValue('--dark-color', this); - options.scales.y.ticks.font.size = getStylePropertyValue('--chart-tick-font-size', this) || 11; + // Gitter & Ticks (v3: grid statt gridLines) + options.scales.x.grid.color = gridColor; + options.scales.x.ticks.font.size = tickSize; - options.scales.y1.gridLines.color = getStylePropertyValue('--chart-grid-line-color', this) || getStylePropertyValue('--dark-color', this); - options.scales.y1.ticks.font.size = getStylePropertyValue('--chart-tick-font-size', this) || 11; + options.scales.y.grid.color = gridColor; + options.scales.y.ticks.font.size = tickSize; + + options.scales.y1.grid.color = gridColor; + options.scales.y1.ticks.font.size= tickSize; this.chart.update(); } - } window.customElements.define('ftui-chart', FtuiChart); +