{"version":3,"file":"vendors/vendors-main-helpers.segment.cjs.bundle.js","mappings":"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","sources":["webpack://typescript/./node_modules/chart.js/dist/chunks/helpers.segment.cjs"],"sourcesContent":["/*!\n * Chart.js v4.4.8\n * https://www.chartjs.org\n * (c) 2025 Chart.js Contributors\n * Released under the MIT License\n */\n'use strict';\n\nvar color$1 = require('@kurkle/color');\n\n/**\n * @namespace Chart.helpers\n */ /**\n * An empty function that can be used, for example, for optional callback.\n */ function noop() {\n/* noop */ }\n/**\n * Returns a unique id, sequentially generated from a global variable.\n */ const uid = (()=>{\n    let id = 0;\n    return ()=>id++;\n})();\n/**\n * Returns true if `value` is neither null nor undefined, else returns false.\n * @param value - The value to test.\n * @since 2.7.0\n */ function isNullOrUndef(value) {\n    return value === null || value === undefined;\n}\n/**\n * Returns true if `value` is an array (including typed arrays), else returns false.\n * @param value - The value to test.\n * @function\n */ function isArray(value) {\n    if (Array.isArray && Array.isArray(value)) {\n        return true;\n    }\n    const type = Object.prototype.toString.call(value);\n    if (type.slice(0, 7) === '[object' && type.slice(-6) === 'Array]') {\n        return true;\n    }\n    return false;\n}\n/**\n * Returns true if `value` is an object (excluding null), else returns false.\n * @param value - The value to test.\n * @since 2.7.0\n */ function isObject(value) {\n    return value !== null && Object.prototype.toString.call(value) === '[object Object]';\n}\n/**\n * Returns true if `value` is a finite number, else returns false\n * @param value  - The value to test.\n */ function isNumberFinite(value) {\n    return (typeof value === 'number' || value instanceof Number) && isFinite(+value);\n}\n/**\n * Returns `value` if finite, else returns `defaultValue`.\n * @param value - The value to return if defined.\n * @param defaultValue - The value to return if `value` is not finite.\n */ function finiteOrDefault(value, defaultValue) {\n    return isNumberFinite(value) ? value : defaultValue;\n}\n/**\n * Returns `value` if defined, else returns `defaultValue`.\n * @param value - The value to return if defined.\n * @param defaultValue - The value to return if `value` is undefined.\n */ function valueOrDefault(value, defaultValue) {\n    return typeof value === 'undefined' ? defaultValue : value;\n}\nconst toPercentage = (value, dimension)=>typeof value === 'string' && value.endsWith('%') ? parseFloat(value) / 100 : +value / dimension;\nconst toDimension = (value, dimension)=>typeof value === 'string' && value.endsWith('%') ? parseFloat(value) / 100 * dimension : +value;\n/**\n * Calls `fn` with the given `args` in the scope defined by `thisArg` and returns the\n * value returned by `fn`. If `fn` is not a function, this method returns undefined.\n * @param fn - The function to call.\n * @param args - The arguments with which `fn` should be called.\n * @param [thisArg] - The value of `this` provided for the call to `fn`.\n */ function callback(fn, args, thisArg) {\n    if (fn && typeof fn.call === 'function') {\n        return fn.apply(thisArg, args);\n    }\n}\nfunction each(loopable, fn, thisArg, reverse) {\n    let i, len, keys;\n    if (isArray(loopable)) {\n        len = loopable.length;\n        if (reverse) {\n            for(i = len - 1; i >= 0; i--){\n                fn.call(thisArg, loopable[i], i);\n            }\n        } else {\n            for(i = 0; i < len; i++){\n                fn.call(thisArg, loopable[i], i);\n            }\n        }\n    } else if (isObject(loopable)) {\n        keys = Object.keys(loopable);\n        len = keys.length;\n        for(i = 0; i < len; i++){\n            fn.call(thisArg, loopable[keys[i]], keys[i]);\n        }\n    }\n}\n/**\n * Returns true if the `a0` and `a1` arrays have the same content, else returns false.\n * @param a0 - The array to compare\n * @param a1 - The array to compare\n * @private\n */ function _elementsEqual(a0, a1) {\n    let i, ilen, v0, v1;\n    if (!a0 || !a1 || a0.length !== a1.length) {\n        return false;\n    }\n    for(i = 0, ilen = a0.length; i < ilen; ++i){\n        v0 = a0[i];\n        v1 = a1[i];\n        if (v0.datasetIndex !== v1.datasetIndex || v0.index !== v1.index) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Returns a deep copy of `source` without keeping references on objects and arrays.\n * @param source - The value to clone.\n */ function clone(source) {\n    if (isArray(source)) {\n        return source.map(clone);\n    }\n    if (isObject(source)) {\n        const target = Object.create(null);\n        const keys = Object.keys(source);\n        const klen = keys.length;\n        let k = 0;\n        for(; k < klen; ++k){\n            target[keys[k]] = clone(source[keys[k]]);\n        }\n        return target;\n    }\n    return source;\n}\nfunction isValidKey(key) {\n    return [\n        '__proto__',\n        'prototype',\n        'constructor'\n    ].indexOf(key) === -1;\n}\n/**\n * The default merger when Chart.helpers.merge is called without merger option.\n * Note(SB): also used by mergeConfig and mergeScaleConfig as fallback.\n * @private\n */ function _merger(key, target, source, options) {\n    if (!isValidKey(key)) {\n        return;\n    }\n    const tval = target[key];\n    const sval = source[key];\n    if (isObject(tval) && isObject(sval)) {\n        // eslint-disable-next-line @typescript-eslint/no-use-before-define\n        merge(tval, sval, options);\n    } else {\n        target[key] = clone(sval);\n    }\n}\nfunction merge(target, source, options) {\n    const sources = isArray(source) ? source : [\n        source\n    ];\n    const ilen = sources.length;\n    if (!isObject(target)) {\n        return target;\n    }\n    options = options || {};\n    const merger = options.merger || _merger;\n    let current;\n    for(let i = 0; i < ilen; ++i){\n        current = sources[i];\n        if (!isObject(current)) {\n            continue;\n        }\n        const keys = Object.keys(current);\n        for(let k = 0, klen = keys.length; k < klen; ++k){\n            merger(keys[k], target, current, options);\n        }\n    }\n    return target;\n}\nfunction mergeIf(target, source) {\n    // eslint-disable-next-line @typescript-eslint/no-use-before-define\n    return merge(target, source, {\n        merger: _mergerIf\n    });\n}\n/**\n * Merges source[key] in target[key] only if target[key] is undefined.\n * @private\n */ function _mergerIf(key, target, source) {\n    if (!isValidKey(key)) {\n        return;\n    }\n    const tval = target[key];\n    const sval = source[key];\n    if (isObject(tval) && isObject(sval)) {\n        mergeIf(tval, sval);\n    } else if (!Object.prototype.hasOwnProperty.call(target, key)) {\n        target[key] = clone(sval);\n    }\n}\n/**\n * @private\n */ function _deprecated(scope, value, previous, current) {\n    if (value !== undefined) {\n        console.warn(scope + ': \"' + previous + '\" is deprecated. Please use \"' + current + '\" instead');\n    }\n}\n// resolveObjectKey resolver cache\nconst keyResolvers = {\n    // Chart.helpers.core resolveObjectKey should resolve empty key to root object\n    '': (v)=>v,\n    // default resolvers\n    x: (o)=>o.x,\n    y: (o)=>o.y\n};\n/**\n * @private\n */ function _splitKey(key) {\n    const parts = key.split('.');\n    const keys = [];\n    let tmp = '';\n    for (const part of parts){\n        tmp += part;\n        if (tmp.endsWith('\\\\')) {\n            tmp = tmp.slice(0, -1) + '.';\n        } else {\n            keys.push(tmp);\n            tmp = '';\n        }\n    }\n    return keys;\n}\nfunction _getKeyResolver(key) {\n    const keys = _splitKey(key);\n    return (obj)=>{\n        for (const k of keys){\n            if (k === '') {\n                break;\n            }\n            obj = obj && obj[k];\n        }\n        return obj;\n    };\n}\nfunction resolveObjectKey(obj, key) {\n    const resolver = keyResolvers[key] || (keyResolvers[key] = _getKeyResolver(key));\n    return resolver(obj);\n}\n/**\n * @private\n */ function _capitalize(str) {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\nconst defined = (value)=>typeof value !== 'undefined';\nconst isFunction = (value)=>typeof value === 'function';\n// Adapted from https://stackoverflow.com/questions/31128855/comparing-ecma6-sets-for-equality#31129384\nconst setsEqual = (a, b)=>{\n    if (a.size !== b.size) {\n        return false;\n    }\n    for (const item of a){\n        if (!b.has(item)) {\n            return false;\n        }\n    }\n    return true;\n};\n/**\n * @param e - The event\n * @private\n */ function _isClickEvent(e) {\n    return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu';\n}\n\n/**\n * @alias Chart.helpers.math\n * @namespace\n */ const PI = Math.PI;\nconst TAU = 2 * PI;\nconst PITAU = TAU + PI;\nconst INFINITY = Number.POSITIVE_INFINITY;\nconst RAD_PER_DEG = PI / 180;\nconst HALF_PI = PI / 2;\nconst QUARTER_PI = PI / 4;\nconst TWO_THIRDS_PI = PI * 2 / 3;\nconst log10 = Math.log10;\nconst sign = Math.sign;\nfunction almostEquals(x, y, epsilon) {\n    return Math.abs(x - y) < epsilon;\n}\n/**\n * Implementation of the nice number algorithm used in determining where axis labels will go\n */ function niceNum(range) {\n    const roundedRange = Math.round(range);\n    range = almostEquals(range, roundedRange, range / 1000) ? roundedRange : range;\n    const niceRange = Math.pow(10, Math.floor(log10(range)));\n    const fraction = range / niceRange;\n    const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10;\n    return niceFraction * niceRange;\n}\n/**\n * Returns an array of factors sorted from 1 to sqrt(value)\n * @private\n */ function _factorize(value) {\n    const result = [];\n    const sqrt = Math.sqrt(value);\n    let i;\n    for(i = 1; i < sqrt; i++){\n        if (value % i === 0) {\n            result.push(i);\n            result.push(value / i);\n        }\n    }\n    if (sqrt === (sqrt | 0)) {\n        result.push(sqrt);\n    }\n    result.sort((a, b)=>a - b).pop();\n    return result;\n}\n/**\n * Verifies that attempting to coerce n to string or number won't throw a TypeError.\n */ function isNonPrimitive(n) {\n    return typeof n === 'symbol' || typeof n === 'object' && n !== null && !(Symbol.toPrimitive in n || 'toString' in n || 'valueOf' in n);\n}\nfunction isNumber(n) {\n    return !isNonPrimitive(n) && !isNaN(parseFloat(n)) && isFinite(n);\n}\nfunction almostWhole(x, epsilon) {\n    const rounded = Math.round(x);\n    return rounded - epsilon <= x && rounded + epsilon >= x;\n}\n/**\n * @private\n */ function _setMinAndMaxByKey(array, target, property) {\n    let i, ilen, value;\n    for(i = 0, ilen = array.length; i < ilen; i++){\n        value = array[i][property];\n        if (!isNaN(value)) {\n            target.min = Math.min(target.min, value);\n            target.max = Math.max(target.max, value);\n        }\n    }\n}\nfunction toRadians(degrees) {\n    return degrees * (PI / 180);\n}\nfunction toDegrees(radians) {\n    return radians * (180 / PI);\n}\n/**\n * Returns the number of decimal places\n * i.e. the number of digits after the decimal point, of the value of this Number.\n * @param x - A number.\n * @returns The number of decimal places.\n * @private\n */ function _decimalPlaces(x) {\n    if (!isNumberFinite(x)) {\n        return;\n    }\n    let e = 1;\n    let p = 0;\n    while(Math.round(x * e) / e !== x){\n        e *= 10;\n        p++;\n    }\n    return p;\n}\n// Gets the angle from vertical upright to the point about a centre.\nfunction getAngleFromPoint(centrePoint, anglePoint) {\n    const distanceFromXCenter = anglePoint.x - centrePoint.x;\n    const distanceFromYCenter = anglePoint.y - centrePoint.y;\n    const radialDistanceFromCenter = Math.sqrt(distanceFromXCenter * distanceFromXCenter + distanceFromYCenter * distanceFromYCenter);\n    let angle = Math.atan2(distanceFromYCenter, distanceFromXCenter);\n    if (angle < -0.5 * PI) {\n        angle += TAU; // make sure the returned angle is in the range of (-PI/2, 3PI/2]\n    }\n    return {\n        angle,\n        distance: radialDistanceFromCenter\n    };\n}\nfunction distanceBetweenPoints(pt1, pt2) {\n    return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));\n}\n/**\n * Shortest distance between angles, in either direction.\n * @private\n */ function _angleDiff(a, b) {\n    return (a - b + PITAU) % TAU - PI;\n}\n/**\n * Normalize angle to be between 0 and 2*PI\n * @private\n */ function _normalizeAngle(a) {\n    return (a % TAU + TAU) % TAU;\n}\n/**\n * @private\n */ function _angleBetween(angle, start, end, sameAngleIsFullCircle) {\n    const a = _normalizeAngle(angle);\n    const s = _normalizeAngle(start);\n    const e = _normalizeAngle(end);\n    const angleToStart = _normalizeAngle(s - a);\n    const angleToEnd = _normalizeAngle(e - a);\n    const startToAngle = _normalizeAngle(a - s);\n    const endToAngle = _normalizeAngle(a - e);\n    return a === s || a === e || sameAngleIsFullCircle && s === e || angleToStart > angleToEnd && startToAngle < endToAngle;\n}\n/**\n * Limit `value` between `min` and `max`\n * @param value\n * @param min\n * @param max\n * @private\n */ function _limitValue(value, min, max) {\n    return Math.max(min, Math.min(max, value));\n}\n/**\n * @param {number} value\n * @private\n */ function _int16Range(value) {\n    return _limitValue(value, -32768, 32767);\n}\n/**\n * @param value\n * @param start\n * @param end\n * @param [epsilon]\n * @private\n */ function _isBetween(value, start, end, epsilon = 1e-6) {\n    return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;\n}\n\nfunction _lookup(table, value, cmp) {\n    cmp = cmp || ((index)=>table[index] < value);\n    let hi = table.length - 1;\n    let lo = 0;\n    let mid;\n    while(hi - lo > 1){\n        mid = lo + hi >> 1;\n        if (cmp(mid)) {\n            lo = mid;\n        } else {\n            hi = mid;\n        }\n    }\n    return {\n        lo,\n        hi\n    };\n}\n/**\n * Binary search\n * @param table - the table search. must be sorted!\n * @param key - property name for the value in each entry\n * @param value - value to find\n * @param last - lookup last index\n * @private\n */ const _lookupByKey = (table, key, value, last)=>_lookup(table, value, last ? (index)=>{\n        const ti = table[index][key];\n        return ti < value || ti === value && table[index + 1][key] === value;\n    } : (index)=>table[index][key] < value);\n/**\n * Reverse binary search\n * @param table - the table search. must be sorted!\n * @param key - property name for the value in each entry\n * @param value - value to find\n * @private\n */ const _rlookupByKey = (table, key, value)=>_lookup(table, value, (index)=>table[index][key] >= value);\n/**\n * Return subset of `values` between `min` and `max` inclusive.\n * Values are assumed to be in sorted order.\n * @param values - sorted array of values\n * @param min - min value\n * @param max - max value\n */ function _filterBetween(values, min, max) {\n    let start = 0;\n    let end = values.length;\n    while(start < end && values[start] < min){\n        start++;\n    }\n    while(end > start && values[end - 1] > max){\n        end--;\n    }\n    return start > 0 || end < values.length ? values.slice(start, end) : values;\n}\nconst arrayEvents = [\n    'push',\n    'pop',\n    'shift',\n    'splice',\n    'unshift'\n];\nfunction listenArrayEvents(array, listener) {\n    if (array._chartjs) {\n        array._chartjs.listeners.push(listener);\n        return;\n    }\n    Object.defineProperty(array, '_chartjs', {\n        configurable: true,\n        enumerable: false,\n        value: {\n            listeners: [\n                listener\n            ]\n        }\n    });\n    arrayEvents.forEach((key)=>{\n        const method = '_onData' + _capitalize(key);\n        const base = array[key];\n        Object.defineProperty(array, key, {\n            configurable: true,\n            enumerable: false,\n            value (...args) {\n                const res = base.apply(this, args);\n                array._chartjs.listeners.forEach((object)=>{\n                    if (typeof object[method] === 'function') {\n                        object[method](...args);\n                    }\n                });\n                return res;\n            }\n        });\n    });\n}\nfunction unlistenArrayEvents(array, listener) {\n    const stub = array._chartjs;\n    if (!stub) {\n        return;\n    }\n    const listeners = stub.listeners;\n    const index = listeners.indexOf(listener);\n    if (index !== -1) {\n        listeners.splice(index, 1);\n    }\n    if (listeners.length > 0) {\n        return;\n    }\n    arrayEvents.forEach((key)=>{\n        delete array[key];\n    });\n    delete array._chartjs;\n}\n/**\n * @param items\n */ function _arrayUnique(items) {\n    const set = new Set(items);\n    if (set.size === items.length) {\n        return items;\n    }\n    return Array.from(set);\n}\n\nfunction fontString(pixelSize, fontStyle, fontFamily) {\n    return fontStyle + ' ' + pixelSize + 'px ' + fontFamily;\n}\n/**\n* Request animation polyfill\n*/ const requestAnimFrame = function() {\n    if (typeof window === 'undefined') {\n        return function(callback) {\n            return callback();\n        };\n    }\n    return window.requestAnimationFrame;\n}();\n/**\n * Throttles calling `fn` once per animation frame\n * Latest arguments are used on the actual call\n */ function throttled(fn, thisArg) {\n    let argsToUse = [];\n    let ticking = false;\n    return function(...args) {\n        // Save the args for use later\n        argsToUse = args;\n        if (!ticking) {\n            ticking = true;\n            requestAnimFrame.call(window, ()=>{\n                ticking = false;\n                fn.apply(thisArg, argsToUse);\n            });\n        }\n    };\n}\n/**\n * Debounces calling `fn` for `delay` ms\n */ function debounce(fn, delay) {\n    let timeout;\n    return function(...args) {\n        if (delay) {\n            clearTimeout(timeout);\n            timeout = setTimeout(fn, delay, args);\n        } else {\n            fn.apply(this, args);\n        }\n        return delay;\n    };\n}\n/**\n * Converts 'start' to 'left', 'end' to 'right' and others to 'center'\n * @private\n */ const _toLeftRightCenter = (align)=>align === 'start' ? 'left' : align === 'end' ? 'right' : 'center';\n/**\n * Returns `start`, `end` or `(start + end) / 2` depending on `align`. Defaults to `center`\n * @private\n */ const _alignStartEnd = (align, start, end)=>align === 'start' ? start : align === 'end' ? end : (start + end) / 2;\n/**\n * Returns `left`, `right` or `(left + right) / 2` depending on `align`. Defaults to `left`\n * @private\n */ const _textX = (align, left, right, rtl)=>{\n    const check = rtl ? 'left' : 'right';\n    return align === check ? right : align === 'center' ? (left + right) / 2 : left;\n};\n/**\n * Return start and count of visible points.\n * @private\n */ function _getStartAndCountOfVisiblePoints(meta, points, animationsDisabled) {\n    const pointCount = points.length;\n    let start = 0;\n    let count = pointCount;\n    if (meta._sorted) {\n        const { iScale , vScale , _parsed  } = meta;\n        const spanGaps = meta.dataset ? meta.dataset.options ? meta.dataset.options.spanGaps : null : null;\n        const axis = iScale.axis;\n        const { min , max , minDefined , maxDefined  } = iScale.getUserBounds();\n        if (minDefined) {\n            start = Math.min(// @ts-expect-error Need to type _parsed\n            _lookupByKey(_parsed, axis, min).lo, // @ts-expect-error Need to fix types on _lookupByKey\n            animationsDisabled ? pointCount : _lookupByKey(points, axis, iScale.getPixelForValue(min)).lo);\n            if (spanGaps) {\n                const distanceToDefinedLo = _parsed.slice(0, start + 1).reverse().findIndex((point)=>!isNullOrUndef(point[vScale.axis]));\n                start -= Math.max(0, distanceToDefinedLo);\n            }\n            start = _limitValue(start, 0, pointCount - 1);\n        }\n        if (maxDefined) {\n            let end = Math.max(// @ts-expect-error Need to type _parsed\n            _lookupByKey(_parsed, iScale.axis, max, true).hi + 1, // @ts-expect-error Need to fix types on _lookupByKey\n            animationsDisabled ? 0 : _lookupByKey(points, axis, iScale.getPixelForValue(max), true).hi + 1);\n            if (spanGaps) {\n                const distanceToDefinedHi = _parsed.slice(end - 1).findIndex((point)=>!isNullOrUndef(point[vScale.axis]));\n                end += Math.max(0, distanceToDefinedHi);\n            }\n            count = _limitValue(end, start, pointCount) - start;\n        } else {\n            count = pointCount - start;\n        }\n    }\n    return {\n        start,\n        count\n    };\n}\n/**\n * Checks if the scale ranges have changed.\n * @param {object} meta - dataset meta.\n * @returns {boolean}\n * @private\n */ function _scaleRangesChanged(meta) {\n    const { xScale , yScale , _scaleRanges  } = meta;\n    const newRanges = {\n        xmin: xScale.min,\n        xmax: xScale.max,\n        ymin: yScale.min,\n        ymax: yScale.max\n    };\n    if (!_scaleRanges) {\n        meta._scaleRanges = newRanges;\n        return true;\n    }\n    const changed = _scaleRanges.xmin !== xScale.min || _scaleRanges.xmax !== xScale.max || _scaleRanges.ymin !== yScale.min || _scaleRanges.ymax !== yScale.max;\n    Object.assign(_scaleRanges, newRanges);\n    return changed;\n}\n\nconst atEdge = (t)=>t === 0 || t === 1;\nconst elasticIn = (t, s, p)=>-(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p));\nconst elasticOut = (t, s, p)=>Math.pow(2, -10 * t) * Math.sin((t - s) * TAU / p) + 1;\n/**\n * Easing functions adapted from Robert Penner's easing equations.\n * @namespace Chart.helpers.easing.effects\n * @see http://www.robertpenner.com/easing/\n */ const effects = {\n    linear: (t)=>t,\n    easeInQuad: (t)=>t * t,\n    easeOutQuad: (t)=>-t * (t - 2),\n    easeInOutQuad: (t)=>(t /= 0.5) < 1 ? 0.5 * t * t : -0.5 * (--t * (t - 2) - 1),\n    easeInCubic: (t)=>t * t * t,\n    easeOutCubic: (t)=>(t -= 1) * t * t + 1,\n    easeInOutCubic: (t)=>(t /= 0.5) < 1 ? 0.5 * t * t * t : 0.5 * ((t -= 2) * t * t + 2),\n    easeInQuart: (t)=>t * t * t * t,\n    easeOutQuart: (t)=>-((t -= 1) * t * t * t - 1),\n    easeInOutQuart: (t)=>(t /= 0.5) < 1 ? 0.5 * t * t * t * t : -0.5 * ((t -= 2) * t * t * t - 2),\n    easeInQuint: (t)=>t * t * t * t * t,\n    easeOutQuint: (t)=>(t -= 1) * t * t * t * t + 1,\n    easeInOutQuint: (t)=>(t /= 0.5) < 1 ? 0.5 * t * t * t * t * t : 0.5 * ((t -= 2) * t * t * t * t + 2),\n    easeInSine: (t)=>-Math.cos(t * HALF_PI) + 1,\n    easeOutSine: (t)=>Math.sin(t * HALF_PI),\n    easeInOutSine: (t)=>-0.5 * (Math.cos(PI * t) - 1),\n    easeInExpo: (t)=>t === 0 ? 0 : Math.pow(2, 10 * (t - 1)),\n    easeOutExpo: (t)=>t === 1 ? 1 : -Math.pow(2, -10 * t) + 1,\n    easeInOutExpo: (t)=>atEdge(t) ? t : t < 0.5 ? 0.5 * Math.pow(2, 10 * (t * 2 - 1)) : 0.5 * (-Math.pow(2, -10 * (t * 2 - 1)) + 2),\n    easeInCirc: (t)=>t >= 1 ? t : -(Math.sqrt(1 - t * t) - 1),\n    easeOutCirc: (t)=>Math.sqrt(1 - (t -= 1) * t),\n    easeInOutCirc: (t)=>(t /= 0.5) < 1 ? -0.5 * (Math.sqrt(1 - t * t) - 1) : 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1),\n    easeInElastic: (t)=>atEdge(t) ? t : elasticIn(t, 0.075, 0.3),\n    easeOutElastic: (t)=>atEdge(t) ? t : elasticOut(t, 0.075, 0.3),\n    easeInOutElastic (t) {\n        const s = 0.1125;\n        const p = 0.45;\n        return atEdge(t) ? t : t < 0.5 ? 0.5 * elasticIn(t * 2, s, p) : 0.5 + 0.5 * elasticOut(t * 2 - 1, s, p);\n    },\n    easeInBack (t) {\n        const s = 1.70158;\n        return t * t * ((s + 1) * t - s);\n    },\n    easeOutBack (t) {\n        const s = 1.70158;\n        return (t -= 1) * t * ((s + 1) * t + s) + 1;\n    },\n    easeInOutBack (t) {\n        let s = 1.70158;\n        if ((t /= 0.5) < 1) {\n            return 0.5 * (t * t * (((s *= 1.525) + 1) * t - s));\n        }\n        return 0.5 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2);\n    },\n    easeInBounce: (t)=>1 - effects.easeOutBounce(1 - t),\n    easeOutBounce (t) {\n        const m = 7.5625;\n        const d = 2.75;\n        if (t < 1 / d) {\n            return m * t * t;\n        }\n        if (t < 2 / d) {\n            return m * (t -= 1.5 / d) * t + 0.75;\n        }\n        if (t < 2.5 / d) {\n            return m * (t -= 2.25 / d) * t + 0.9375;\n        }\n        return m * (t -= 2.625 / d) * t + 0.984375;\n    },\n    easeInOutBounce: (t)=>t < 0.5 ? effects.easeInBounce(t * 2) * 0.5 : effects.easeOutBounce(t * 2 - 1) * 0.5 + 0.5\n};\n\nfunction isPatternOrGradient(value) {\n    if (value && typeof value === 'object') {\n        const type = value.toString();\n        return type === '[object CanvasPattern]' || type === '[object CanvasGradient]';\n    }\n    return false;\n}\nfunction color(value) {\n    return isPatternOrGradient(value) ? value : new color$1.Color(value);\n}\nfunction getHoverColor(value) {\n    return isPatternOrGradient(value) ? value : new color$1.Color(value).saturate(0.5).darken(0.1).hexString();\n}\n\nconst numbers = [\n    'x',\n    'y',\n    'borderWidth',\n    'radius',\n    'tension'\n];\nconst colors = [\n    'color',\n    'borderColor',\n    'backgroundColor'\n];\nfunction applyAnimationsDefaults(defaults) {\n    defaults.set('animation', {\n        delay: undefined,\n        duration: 1000,\n        easing: 'easeOutQuart',\n        fn: undefined,\n        from: undefined,\n        loop: undefined,\n        to: undefined,\n        type: undefined\n    });\n    defaults.describe('animation', {\n        _fallback: false,\n        _indexable: false,\n        _scriptable: (name)=>name !== 'onProgress' && name !== 'onComplete' && name !== 'fn'\n    });\n    defaults.set('animations', {\n        colors: {\n            type: 'color',\n            properties: colors\n        },\n        numbers: {\n            type: 'number',\n            properties: numbers\n        }\n    });\n    defaults.describe('animations', {\n        _fallback: 'animation'\n    });\n    defaults.set('transitions', {\n        active: {\n            animation: {\n                duration: 400\n            }\n        },\n        resize: {\n            animation: {\n                duration: 0\n            }\n        },\n        show: {\n            animations: {\n                colors: {\n                    from: 'transparent'\n                },\n                visible: {\n                    type: 'boolean',\n                    duration: 0\n                }\n            }\n        },\n        hide: {\n            animations: {\n                colors: {\n                    to: 'transparent'\n                },\n                visible: {\n                    type: 'boolean',\n                    easing: 'linear',\n                    fn: (v)=>v | 0\n                }\n            }\n        }\n    });\n}\n\nfunction applyLayoutsDefaults(defaults) {\n    defaults.set('layout', {\n        autoPadding: true,\n        padding: {\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0\n        }\n    });\n}\n\nconst intlCache = new Map();\nfunction getNumberFormat(locale, options) {\n    options = options || {};\n    const cacheKey = locale + JSON.stringify(options);\n    let formatter = intlCache.get(cacheKey);\n    if (!formatter) {\n        formatter = new Intl.NumberFormat(locale, options);\n        intlCache.set(cacheKey, formatter);\n    }\n    return formatter;\n}\nfunction formatNumber(num, locale, options) {\n    return getNumberFormat(locale, options).format(num);\n}\n\nconst formatters = {\n values (value) {\n        return isArray(value) ?  value : '' + value;\n    },\n numeric (tickValue, index, ticks) {\n        if (tickValue === 0) {\n            return '0';\n        }\n        const locale = this.chart.options.locale;\n        let notation;\n        let delta = tickValue;\n        if (ticks.length > 1) {\n            const maxTick = Math.max(Math.abs(ticks[0].value), Math.abs(ticks[ticks.length - 1].value));\n            if (maxTick < 1e-4 || maxTick > 1e+15) {\n                notation = 'scientific';\n            }\n            delta = calculateDelta(tickValue, ticks);\n        }\n        const logDelta = log10(Math.abs(delta));\n        const numDecimal = isNaN(logDelta) ? 1 : Math.max(Math.min(-1 * Math.floor(logDelta), 20), 0);\n        const options = {\n            notation,\n            minimumFractionDigits: numDecimal,\n            maximumFractionDigits: numDecimal\n        };\n        Object.assign(options, this.options.ticks.format);\n        return formatNumber(tickValue, locale, options);\n    },\n logarithmic (tickValue, index, ticks) {\n        if (tickValue === 0) {\n            return '0';\n        }\n        const remain = ticks[index].significand || tickValue / Math.pow(10, Math.floor(log10(tickValue)));\n        if ([\n            1,\n            2,\n            3,\n            5,\n            10,\n            15\n        ].includes(remain) || index > 0.8 * ticks.length) {\n            return formatters.numeric.call(this, tickValue, index, ticks);\n        }\n        return '';\n    }\n};\nfunction calculateDelta(tickValue, ticks) {\n    let delta = ticks.length > 3 ? ticks[2].value - ticks[1].value : ticks[1].value - ticks[0].value;\n    if (Math.abs(delta) >= 1 && tickValue !== Math.floor(tickValue)) {\n        delta = tickValue - Math.floor(tickValue);\n    }\n    return delta;\n}\n var Ticks = {\n    formatters\n};\n\nfunction applyScaleDefaults(defaults) {\n    defaults.set('scale', {\n        display: true,\n        offset: false,\n        reverse: false,\n        beginAtZero: false,\n bounds: 'ticks',\n        clip: true,\n grace: 0,\n        grid: {\n            display: true,\n            lineWidth: 1,\n            drawOnChartArea: true,\n            drawTicks: true,\n            tickLength: 8,\n            tickWidth: (_ctx, options)=>options.lineWidth,\n            tickColor: (_ctx, options)=>options.color,\n            offset: false\n        },\n        border: {\n            display: true,\n            dash: [],\n            dashOffset: 0.0,\n            width: 1\n        },\n        title: {\n            display: false,\n            text: '',\n            padding: {\n                top: 4,\n                bottom: 4\n            }\n        },\n        ticks: {\n            minRotation: 0,\n            maxRotation: 50,\n            mirror: false,\n            textStrokeWidth: 0,\n            textStrokeColor: '',\n            padding: 3,\n            display: true,\n            autoSkip: true,\n            autoSkipPadding: 3,\n            labelOffset: 0,\n            callback: Ticks.formatters.values,\n            minor: {},\n            major: {},\n            align: 'center',\n            crossAlign: 'near',\n            showLabelBackdrop: false,\n            backdropColor: 'rgba(255, 255, 255, 0.75)',\n            backdropPadding: 2\n        }\n    });\n    defaults.route('scale.ticks', 'color', '', 'color');\n    defaults.route('scale.grid', 'color', '', 'borderColor');\n    defaults.route('scale.border', 'color', '', 'borderColor');\n    defaults.route('scale.title', 'color', '', 'color');\n    defaults.describe('scale', {\n        _fallback: false,\n        _scriptable: (name)=>!name.startsWith('before') && !name.startsWith('after') && name !== 'callback' && name !== 'parser',\n        _indexable: (name)=>name !== 'borderDash' && name !== 'tickBorderDash' && name !== 'dash'\n    });\n    defaults.describe('scales', {\n        _fallback: 'scale'\n    });\n    defaults.describe('scale.ticks', {\n        _scriptable: (name)=>name !== 'backdropPadding' && name !== 'callback',\n        _indexable: (name)=>name !== 'backdropPadding'\n    });\n}\n\nconst overrides = Object.create(null);\nconst descriptors = Object.create(null);\n function getScope$1(node, key) {\n    if (!key) {\n        return node;\n    }\n    const keys = key.split('.');\n    for(let i = 0, n = keys.length; i < n; ++i){\n        const k = keys[i];\n        node = node[k] || (node[k] = Object.create(null));\n    }\n    return node;\n}\nfunction set(root, scope, values) {\n    if (typeof scope === 'string') {\n        return merge(getScope$1(root, scope), values);\n    }\n    return merge(getScope$1(root, ''), scope);\n}\n class Defaults {\n    constructor(_descriptors, _appliers){\n        this.animation = undefined;\n        this.backgroundColor = 'rgba(0,0,0,0.1)';\n        this.borderColor = 'rgba(0,0,0,0.1)';\n        this.color = '#666';\n        this.datasets = {};\n        this.devicePixelRatio = (context)=>context.chart.platform.getDevicePixelRatio();\n        this.elements = {};\n        this.events = [\n            'mousemove',\n            'mouseout',\n            'click',\n            'touchstart',\n            'touchmove'\n        ];\n        this.font = {\n            family: \"'Helvetica Neue', 'Helvetica', 'Arial', sans-serif\",\n            size: 12,\n            style: 'normal',\n            lineHeight: 1.2,\n            weight: null\n        };\n        this.hover = {};\n        this.hoverBackgroundColor = (ctx, options)=>getHoverColor(options.backgroundColor);\n        this.hoverBorderColor = (ctx, options)=>getHoverColor(options.borderColor);\n        this.hoverColor = (ctx, options)=>getHoverColor(options.color);\n        this.indexAxis = 'x';\n        this.interaction = {\n            mode: 'nearest',\n            intersect: true,\n            includeInvisible: false\n        };\n        this.maintainAspectRatio = true;\n        this.onHover = null;\n        this.onClick = null;\n        this.parsing = true;\n        this.plugins = {};\n        this.responsive = true;\n        this.scale = undefined;\n        this.scales = {};\n        this.showLine = true;\n        this.drawActiveElementsOnTop = true;\n        this.describe(_descriptors);\n        this.apply(_appliers);\n    }\n set(scope, values) {\n        return set(this, scope, values);\n    }\n get(scope) {\n        return getScope$1(this, scope);\n    }\n describe(scope, values) {\n        return set(descriptors, scope, values);\n    }\n    override(scope, values) {\n        return set(overrides, scope, values);\n    }\n route(scope, name, targetScope, targetName) {\n        const scopeObject = getScope$1(this, scope);\n        const targetScopeObject = getScope$1(this, targetScope);\n        const privateName = '_' + name;\n        Object.defineProperties(scopeObject, {\n            [privateName]: {\n                value: scopeObject[name],\n                writable: true\n            },\n            [name]: {\n                enumerable: true,\n                get () {\n                    const local = this[privateName];\n                    const target = targetScopeObject[targetName];\n                    if (isObject(local)) {\n                        return Object.assign({}, target, local);\n                    }\n                    return valueOrDefault(local, target);\n                },\n                set (value) {\n                    this[privateName] = value;\n                }\n            }\n        });\n    }\n    apply(appliers) {\n        appliers.forEach((apply)=>apply(this));\n    }\n}\nvar defaults = /* #__PURE__ */ new Defaults({\n    _scriptable: (name)=>!name.startsWith('on'),\n    _indexable: (name)=>name !== 'events',\n    hover: {\n        _fallback: 'interaction'\n    },\n    interaction: {\n        _scriptable: false,\n        _indexable: false\n    }\n}, [\n    applyAnimationsDefaults,\n    applyLayoutsDefaults,\n    applyScaleDefaults\n]);\n\n/**\n * Converts the given font object into a CSS font string.\n * @param font - A font object.\n * @return The CSS font string. See https://developer.mozilla.org/en-US/docs/Web/CSS/font\n * @private\n */ function toFontString(font) {\n    if (!font || isNullOrUndef(font.size) || isNullOrUndef(font.family)) {\n        return null;\n    }\n    return (font.style ? font.style + ' ' : '') + (font.weight ? font.weight + ' ' : '') + font.size + 'px ' + font.family;\n}\n/**\n * @private\n */ function _measureText(ctx, data, gc, longest, string) {\n    let textWidth = data[string];\n    if (!textWidth) {\n        textWidth = data[string] = ctx.measureText(string).width;\n        gc.push(string);\n    }\n    if (textWidth > longest) {\n        longest = textWidth;\n    }\n    return longest;\n}\n/**\n * @private\n */ // eslint-disable-next-line complexity\nfunction _longestText(ctx, font, arrayOfThings, cache) {\n    cache = cache || {};\n    let data = cache.data = cache.data || {};\n    let gc = cache.garbageCollect = cache.garbageCollect || [];\n    if (cache.font !== font) {\n        data = cache.data = {};\n        gc = cache.garbageCollect = [];\n        cache.font = font;\n    }\n    ctx.save();\n    ctx.font = font;\n    let longest = 0;\n    const ilen = arrayOfThings.length;\n    let i, j, jlen, thing, nestedThing;\n    for(i = 0; i < ilen; i++){\n        thing = arrayOfThings[i];\n        // Undefined strings and arrays should not be measured\n        if (thing !== undefined && thing !== null && !isArray(thing)) {\n            longest = _measureText(ctx, data, gc, longest, thing);\n        } else if (isArray(thing)) {\n            // if it is an array lets measure each element\n            // to do maybe simplify this function a bit so we can do this more recursively?\n            for(j = 0, jlen = thing.length; j < jlen; j++){\n                nestedThing = thing[j];\n                // Undefined strings and arrays should not be measured\n                if (nestedThing !== undefined && nestedThing !== null && !isArray(nestedThing)) {\n                    longest = _measureText(ctx, data, gc, longest, nestedThing);\n                }\n            }\n        }\n    }\n    ctx.restore();\n    const gcLen = gc.length / 2;\n    if (gcLen > arrayOfThings.length) {\n        for(i = 0; i < gcLen; i++){\n            delete data[gc[i]];\n        }\n        gc.splice(0, gcLen);\n    }\n    return longest;\n}\n/**\n * Returns the aligned pixel value to avoid anti-aliasing blur\n * @param chart - The chart instance.\n * @param pixel - A pixel value.\n * @param width - The width of the element.\n * @returns The aligned pixel value.\n * @private\n */ function _alignPixel(chart, pixel, width) {\n    const devicePixelRatio = chart.currentDevicePixelRatio;\n    const halfWidth = width !== 0 ? Math.max(width / 2, 0.5) : 0;\n    return Math.round((pixel - halfWidth) * devicePixelRatio) / devicePixelRatio + halfWidth;\n}\n/**\n * Clears the entire canvas.\n */ function clearCanvas(canvas, ctx) {\n    if (!ctx && !canvas) {\n        return;\n    }\n    ctx = ctx || canvas.getContext('2d');\n    ctx.save();\n    // canvas.width and canvas.height do not consider the canvas transform,\n    // while clearRect does\n    ctx.resetTransform();\n    ctx.clearRect(0, 0, canvas.width, canvas.height);\n    ctx.restore();\n}\nfunction drawPoint(ctx, options, x, y) {\n    // eslint-disable-next-line @typescript-eslint/no-use-before-define\n    drawPointLegend(ctx, options, x, y, null);\n}\n// eslint-disable-next-line complexity\nfunction drawPointLegend(ctx, options, x, y, w) {\n    let type, xOffset, yOffset, size, cornerRadius, width, xOffsetW, yOffsetW;\n    const style = options.pointStyle;\n    const rotation = options.rotation;\n    const radius = options.radius;\n    let rad = (rotation || 0) * RAD_PER_DEG;\n    if (style && typeof style === 'object') {\n        type = style.toString();\n        if (type === '[object HTMLImageElement]' || type === '[object HTMLCanvasElement]') {\n            ctx.save();\n            ctx.translate(x, y);\n            ctx.rotate(rad);\n            ctx.drawImage(style, -style.width / 2, -style.height / 2, style.width, style.height);\n            ctx.restore();\n            return;\n        }\n    }\n    if (isNaN(radius) || radius <= 0) {\n        return;\n    }\n    ctx.beginPath();\n    switch(style){\n        // Default includes circle\n        default:\n            if (w) {\n                ctx.ellipse(x, y, w / 2, radius, 0, 0, TAU);\n            } else {\n                ctx.arc(x, y, radius, 0, TAU);\n            }\n            ctx.closePath();\n            break;\n        case 'triangle':\n            width = w ? w / 2 : radius;\n            ctx.moveTo(x + Math.sin(rad) * width, y - Math.cos(rad) * radius);\n            rad += TWO_THIRDS_PI;\n            ctx.lineTo(x + Math.sin(rad) * width, y - Math.cos(rad) * radius);\n            rad += TWO_THIRDS_PI;\n            ctx.lineTo(x + Math.sin(rad) * width, y - Math.cos(rad) * radius);\n            ctx.closePath();\n            break;\n        case 'rectRounded':\n            // NOTE: the rounded rect implementation changed to use `arc` instead of\n            // `quadraticCurveTo` since it generates better results when rect is\n            // almost a circle. 0.516 (instead of 0.5) produces results with visually\n            // closer proportion to the previous impl and it is inscribed in the\n            // circle with `radius`. For more details, see the following PRs:\n            // https://github.com/chartjs/Chart.js/issues/5597\n            // https://github.com/chartjs/Chart.js/issues/5858\n            cornerRadius = radius * 0.516;\n            size = radius - cornerRadius;\n            xOffset = Math.cos(rad + QUARTER_PI) * size;\n            xOffsetW = Math.cos(rad + QUARTER_PI) * (w ? w / 2 - cornerRadius : size);\n            yOffset = Math.sin(rad + QUARTER_PI) * size;\n            yOffsetW = Math.sin(rad + QUARTER_PI) * (w ? w / 2 - cornerRadius : size);\n            ctx.arc(x - xOffsetW, y - yOffset, cornerRadius, rad - PI, rad - HALF_PI);\n            ctx.arc(x + yOffsetW, y - xOffset, cornerRadius, rad - HALF_PI, rad);\n            ctx.arc(x + xOffsetW, y + yOffset, cornerRadius, rad, rad + HALF_PI);\n            ctx.arc(x - yOffsetW, y + xOffset, cornerRadius, rad + HALF_PI, rad + PI);\n            ctx.closePath();\n            break;\n        case 'rect':\n            if (!rotation) {\n                size = Math.SQRT1_2 * radius;\n                width = w ? w / 2 : size;\n                ctx.rect(x - width, y - size, 2 * width, 2 * size);\n                break;\n            }\n            rad += QUARTER_PI;\n        /* falls through */ case 'rectRot':\n            xOffsetW = Math.cos(rad) * (w ? w / 2 : radius);\n            xOffset = Math.cos(rad) * radius;\n            yOffset = Math.sin(rad) * radius;\n            yOffsetW = Math.sin(rad) * (w ? w / 2 : radius);\n            ctx.moveTo(x - xOffsetW, y - yOffset);\n            ctx.lineTo(x + yOffsetW, y - xOffset);\n            ctx.lineTo(x + xOffsetW, y + yOffset);\n            ctx.lineTo(x - yOffsetW, y + xOffset);\n            ctx.closePath();\n            break;\n        case 'crossRot':\n            rad += QUARTER_PI;\n        /* falls through */ case 'cross':\n            xOffsetW = Math.cos(rad) * (w ? w / 2 : radius);\n            xOffset = Math.cos(rad) * radius;\n            yOffset = Math.sin(rad) * radius;\n            yOffsetW = Math.sin(rad) * (w ? w / 2 : radius);\n            ctx.moveTo(x - xOffsetW, y - yOffset);\n            ctx.lineTo(x + xOffsetW, y + yOffset);\n            ctx.moveTo(x + yOffsetW, y - xOffset);\n            ctx.lineTo(x - yOffsetW, y + xOffset);\n            break;\n        case 'star':\n            xOffsetW = Math.cos(rad) * (w ? w / 2 : radius);\n            xOffset = Math.cos(rad) * radius;\n            yOffset = Math.sin(rad) * radius;\n            yOffsetW = Math.sin(rad) * (w ? w / 2 : radius);\n            ctx.moveTo(x - xOffsetW, y - yOffset);\n            ctx.lineTo(x + xOffsetW, y + yOffset);\n            ctx.moveTo(x + yOffsetW, y - xOffset);\n            ctx.lineTo(x - yOffsetW, y + xOffset);\n            rad += QUARTER_PI;\n            xOffsetW = Math.cos(rad) * (w ? w / 2 : radius);\n            xOffset = Math.cos(rad) * radius;\n            yOffset = Math.sin(rad) * radius;\n            yOffsetW = Math.sin(rad) * (w ? w / 2 : radius);\n            ctx.moveTo(x - xOffsetW, y - yOffset);\n            ctx.lineTo(x + xOffsetW, y + yOffset);\n            ctx.moveTo(x + yOffsetW, y - xOffset);\n            ctx.lineTo(x - yOffsetW, y + xOffset);\n            break;\n        case 'line':\n            xOffset = w ? w / 2 : Math.cos(rad) * radius;\n            yOffset = Math.sin(rad) * radius;\n            ctx.moveTo(x - xOffset, y - yOffset);\n            ctx.lineTo(x + xOffset, y + yOffset);\n            break;\n        case 'dash':\n            ctx.moveTo(x, y);\n            ctx.lineTo(x + Math.cos(rad) * (w ? w / 2 : radius), y + Math.sin(rad) * radius);\n            break;\n        case false:\n            ctx.closePath();\n            break;\n    }\n    ctx.fill();\n    if (options.borderWidth > 0) {\n        ctx.stroke();\n    }\n}\n/**\n * Returns true if the point is inside the rectangle\n * @param point - The point to test\n * @param area - The rectangle\n * @param margin - allowed margin\n * @private\n */ function _isPointInArea(point, area, margin) {\n    margin = margin || 0.5; // margin - default is to match rounded decimals\n    return !area || point && point.x > area.left - margin && point.x < area.right + margin && point.y > area.top - margin && point.y < area.bottom + margin;\n}\nfunction clipArea(ctx, area) {\n    ctx.save();\n    ctx.beginPath();\n    ctx.rect(area.left, area.top, area.right - area.left, area.bottom - area.top);\n    ctx.clip();\n}\nfunction unclipArea(ctx) {\n    ctx.restore();\n}\n/**\n * @private\n */ function _steppedLineTo(ctx, previous, target, flip, mode) {\n    if (!previous) {\n        return ctx.lineTo(target.x, target.y);\n    }\n    if (mode === 'middle') {\n        const midpoint = (previous.x + target.x) / 2.0;\n        ctx.lineTo(midpoint, previous.y);\n        ctx.lineTo(midpoint, target.y);\n    } else if (mode === 'after' !== !!flip) {\n        ctx.lineTo(previous.x, target.y);\n    } else {\n        ctx.lineTo(target.x, previous.y);\n    }\n    ctx.lineTo(target.x, target.y);\n}\n/**\n * @private\n */ function _bezierCurveTo(ctx, previous, target, flip) {\n    if (!previous) {\n        return ctx.lineTo(target.x, target.y);\n    }\n    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);\n}\nfunction setRenderOpts(ctx, opts) {\n    if (opts.translation) {\n        ctx.translate(opts.translation[0], opts.translation[1]);\n    }\n    if (!isNullOrUndef(opts.rotation)) {\n        ctx.rotate(opts.rotation);\n    }\n    if (opts.color) {\n        ctx.fillStyle = opts.color;\n    }\n    if (opts.textAlign) {\n        ctx.textAlign = opts.textAlign;\n    }\n    if (opts.textBaseline) {\n        ctx.textBaseline = opts.textBaseline;\n    }\n}\nfunction decorateText(ctx, x, y, line, opts) {\n    if (opts.strikethrough || opts.underline) {\n        /**\n     * Now that IE11 support has been dropped, we can use more\n     * of the TextMetrics object. The actual bounding boxes\n     * are unflagged in Chrome, Firefox, Edge, and Safari so they\n     * can be safely used.\n     * See https://developer.mozilla.org/en-US/docs/Web/API/TextMetrics#Browser_compatibility\n     */ const metrics = ctx.measureText(line);\n        const left = x - metrics.actualBoundingBoxLeft;\n        const right = x + metrics.actualBoundingBoxRight;\n        const top = y - metrics.actualBoundingBoxAscent;\n        const bottom = y + metrics.actualBoundingBoxDescent;\n        const yDecoration = opts.strikethrough ? (top + bottom) / 2 : bottom;\n        ctx.strokeStyle = ctx.fillStyle;\n        ctx.beginPath();\n        ctx.lineWidth = opts.decorationWidth || 2;\n        ctx.moveTo(left, yDecoration);\n        ctx.lineTo(right, yDecoration);\n        ctx.stroke();\n    }\n}\nfunction drawBackdrop(ctx, opts) {\n    const oldColor = ctx.fillStyle;\n    ctx.fillStyle = opts.color;\n    ctx.fillRect(opts.left, opts.top, opts.width, opts.height);\n    ctx.fillStyle = oldColor;\n}\n/**\n * Render text onto the canvas\n */ function renderText(ctx, text, x, y, font, opts = {}) {\n    const lines = isArray(text) ? text : [\n        text\n    ];\n    const stroke = opts.strokeWidth > 0 && opts.strokeColor !== '';\n    let i, line;\n    ctx.save();\n    ctx.font = font.string;\n    setRenderOpts(ctx, opts);\n    for(i = 0; i < lines.length; ++i){\n        line = lines[i];\n        if (opts.backdrop) {\n            drawBackdrop(ctx, opts.backdrop);\n        }\n        if (stroke) {\n            if (opts.strokeColor) {\n                ctx.strokeStyle = opts.strokeColor;\n            }\n            if (!isNullOrUndef(opts.strokeWidth)) {\n                ctx.lineWidth = opts.strokeWidth;\n            }\n            ctx.strokeText(line, x, y, opts.maxWidth);\n        }\n        ctx.fillText(line, x, y, opts.maxWidth);\n        decorateText(ctx, x, y, line, opts);\n        y += Number(font.lineHeight);\n    }\n    ctx.restore();\n}\n/**\n * Add a path of a rectangle with rounded corners to the current sub-path\n * @param ctx - Context\n * @param rect - Bounding rect\n */ function addRoundedRectPath(ctx, rect) {\n    const { x , y , w , h , radius  } = rect;\n    // top left arc\n    ctx.arc(x + radius.topLeft, y + radius.topLeft, radius.topLeft, 1.5 * PI, PI, true);\n    // line from top left to bottom left\n    ctx.lineTo(x, y + h - radius.bottomLeft);\n    // bottom left arc\n    ctx.arc(x + radius.bottomLeft, y + h - radius.bottomLeft, radius.bottomLeft, PI, HALF_PI, true);\n    // line from bottom left to bottom right\n    ctx.lineTo(x + w - radius.bottomRight, y + h);\n    // bottom right arc\n    ctx.arc(x + w - radius.bottomRight, y + h - radius.bottomRight, radius.bottomRight, HALF_PI, 0, true);\n    // line from bottom right to top right\n    ctx.lineTo(x + w, y + radius.topRight);\n    // top right arc\n    ctx.arc(x + w - radius.topRight, y + radius.topRight, radius.topRight, 0, -HALF_PI, true);\n    // line from top right to top left\n    ctx.lineTo(x + radius.topLeft, y);\n}\n\nconst LINE_HEIGHT = /^(normal|(\\d+(?:\\.\\d+)?)(px|em|%)?)$/;\nconst FONT_STYLE = /^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;\n/**\n * @alias Chart.helpers.options\n * @namespace\n */ /**\n * Converts the given line height `value` in pixels for a specific font `size`.\n * @param value - The lineHeight to parse (eg. 1.6, '14px', '75%', '1.6em').\n * @param size - The font size (in pixels) used to resolve relative `value`.\n * @returns The effective line height in pixels (size * 1.2 if value is invalid).\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/line-height\n * @since 2.7.0\n */ function toLineHeight(value, size) {\n    const matches = ('' + value).match(LINE_HEIGHT);\n    if (!matches || matches[1] === 'normal') {\n        return size * 1.2;\n    }\n    value = +matches[2];\n    switch(matches[3]){\n        case 'px':\n            return value;\n        case '%':\n            value /= 100;\n            break;\n    }\n    return size * value;\n}\nconst numberOrZero = (v)=>+v || 0;\nfunction _readValueToProps(value, props) {\n    const ret = {};\n    const objProps = isObject(props);\n    const keys = objProps ? Object.keys(props) : props;\n    const read = isObject(value) ? objProps ? (prop)=>valueOrDefault(value[prop], value[props[prop]]) : (prop)=>value[prop] : ()=>value;\n    for (const prop of keys){\n        ret[prop] = numberOrZero(read(prop));\n    }\n    return ret;\n}\n/**\n * Converts the given value into a TRBL object.\n * @param value - If a number, set the value to all TRBL component,\n *  else, if an object, use defined properties and sets undefined ones to 0.\n *  x / y are shorthands for same value for left/right and top/bottom.\n * @returns The padding values (top, right, bottom, left)\n * @since 3.0.0\n */ function toTRBL(value) {\n    return _readValueToProps(value, {\n        top: 'y',\n        right: 'x',\n        bottom: 'y',\n        left: 'x'\n    });\n}\n/**\n * Converts the given value into a TRBL corners object (similar with css border-radius).\n * @param value - If a number, set the value to all TRBL corner components,\n *  else, if an object, use defined properties and sets undefined ones to 0.\n * @returns The TRBL corner values (topLeft, topRight, bottomLeft, bottomRight)\n * @since 3.0.0\n */ function toTRBLCorners(value) {\n    return _readValueToProps(value, [\n        'topLeft',\n        'topRight',\n        'bottomLeft',\n        'bottomRight'\n    ]);\n}\n/**\n * Converts the given value into a padding object with pre-computed width/height.\n * @param value - If a number, set the value to all TRBL component,\n *  else, if an object, use defined properties and sets undefined ones to 0.\n *  x / y are shorthands for same value for left/right and top/bottom.\n * @returns The padding values (top, right, bottom, left, width, height)\n * @since 2.7.0\n */ function toPadding(value) {\n    const obj = toTRBL(value);\n    obj.width = obj.left + obj.right;\n    obj.height = obj.top + obj.bottom;\n    return obj;\n}\n/**\n * Parses font options and returns the font object.\n * @param options - A object that contains font options to be parsed.\n * @param fallback - A object that contains fallback font options.\n * @return The font object.\n * @private\n */ function toFont(options, fallback) {\n    options = options || {};\n    fallback = fallback || defaults.font;\n    let size = valueOrDefault(options.size, fallback.size);\n    if (typeof size === 'string') {\n        size = parseInt(size, 10);\n    }\n    let style = valueOrDefault(options.style, fallback.style);\n    if (style && !('' + style).match(FONT_STYLE)) {\n        console.warn('Invalid font style specified: \"' + style + '\"');\n        style = undefined;\n    }\n    const font = {\n        family: valueOrDefault(options.family, fallback.family),\n        lineHeight: toLineHeight(valueOrDefault(options.lineHeight, fallback.lineHeight), size),\n        size,\n        style,\n        weight: valueOrDefault(options.weight, fallback.weight),\n        string: ''\n    };\n    font.string = toFontString(font);\n    return font;\n}\n/**\n * Evaluates the given `inputs` sequentially and returns the first defined value.\n * @param inputs - An array of values, falling back to the last value.\n * @param context - If defined and the current value is a function, the value\n * is called with `context` as first argument and the result becomes the new input.\n * @param index - If defined and the current value is an array, the value\n * at `index` become the new input.\n * @param info - object to return information about resolution in\n * @param info.cacheable - Will be set to `false` if option is not cacheable.\n * @since 2.7.0\n */ function resolve(inputs, context, index, info) {\n    let cacheable = true;\n    let i, ilen, value;\n    for(i = 0, ilen = inputs.length; i < ilen; ++i){\n        value = inputs[i];\n        if (value === undefined) {\n            continue;\n        }\n        if (context !== undefined && typeof value === 'function') {\n            value = value(context);\n            cacheable = false;\n        }\n        if (index !== undefined && isArray(value)) {\n            value = value[index % value.length];\n            cacheable = false;\n        }\n        if (value !== undefined) {\n            if (info && !cacheable) {\n                info.cacheable = false;\n            }\n            return value;\n        }\n    }\n}\n/**\n * @param minmax\n * @param grace\n * @param beginAtZero\n * @private\n */ function _addGrace(minmax, grace, beginAtZero) {\n    const { min , max  } = minmax;\n    const change = toDimension(grace, (max - min) / 2);\n    const keepZero = (value, add)=>beginAtZero && value === 0 ? 0 : value + add;\n    return {\n        min: keepZero(min, -Math.abs(change)),\n        max: keepZero(max, change)\n    };\n}\nfunction createContext(parentContext, context) {\n    return Object.assign(Object.create(parentContext), context);\n}\n\n/**\n * Creates a Proxy for resolving raw values for options.\n * @param scopes - The option scopes to look for values, in resolution order\n * @param prefixes - The prefixes for values, in resolution order.\n * @param rootScopes - The root option scopes\n * @param fallback - Parent scopes fallback\n * @param getTarget - callback for getting the target for changed values\n * @returns Proxy\n * @private\n */ function _createResolver(scopes, prefixes = [\n    ''\n], rootScopes, fallback, getTarget = ()=>scopes[0]) {\n    const finalRootScopes = rootScopes || scopes;\n    if (typeof fallback === 'undefined') {\n        fallback = _resolve('_fallback', scopes);\n    }\n    const cache = {\n        [Symbol.toStringTag]: 'Object',\n        _cacheable: true,\n        _scopes: scopes,\n        _rootScopes: finalRootScopes,\n        _fallback: fallback,\n        _getTarget: getTarget,\n        override: (scope)=>_createResolver([\n                scope,\n                ...scopes\n            ], prefixes, finalRootScopes, fallback)\n    };\n    return new Proxy(cache, {\n        /**\n     * A trap for the delete operator.\n     */ deleteProperty (target, prop) {\n            delete target[prop]; // remove from cache\n            delete target._keys; // remove cached keys\n            delete scopes[0][prop]; // remove from top level scope\n            return true;\n        },\n        /**\n     * A trap for getting property values.\n     */ get (target, prop) {\n            return _cached(target, prop, ()=>_resolveWithPrefixes(prop, prefixes, scopes, target));\n        },\n        /**\n     * A trap for Object.getOwnPropertyDescriptor.\n     * Also used by Object.hasOwnProperty.\n     */ getOwnPropertyDescriptor (target, prop) {\n            return Reflect.getOwnPropertyDescriptor(target._scopes[0], prop);\n        },\n        /**\n     * A trap for Object.getPrototypeOf.\n     */ getPrototypeOf () {\n            return Reflect.getPrototypeOf(scopes[0]);\n        },\n        /**\n     * A trap for the in operator.\n     */ has (target, prop) {\n            return getKeysFromAllScopes(target).includes(prop);\n        },\n        /**\n     * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.\n     */ ownKeys (target) {\n            return getKeysFromAllScopes(target);\n        },\n        /**\n     * A trap for setting property values.\n     */ set (target, prop, value) {\n            const storage = target._storage || (target._storage = getTarget());\n            target[prop] = storage[prop] = value; // set to top level scope + cache\n            delete target._keys; // remove cached keys\n            return true;\n        }\n    });\n}\n/**\n * Returns an Proxy for resolving option values with context.\n * @param proxy - The Proxy returned by `_createResolver`\n * @param context - Context object for scriptable/indexable options\n * @param subProxy - The proxy provided for scriptable options\n * @param descriptorDefaults - Defaults for descriptors\n * @private\n */ function _attachContext(proxy, context, subProxy, descriptorDefaults) {\n    const cache = {\n        _cacheable: false,\n        _proxy: proxy,\n        _context: context,\n        _subProxy: subProxy,\n        _stack: new Set(),\n        _descriptors: _descriptors(proxy, descriptorDefaults),\n        setContext: (ctx)=>_attachContext(proxy, ctx, subProxy, descriptorDefaults),\n        override: (scope)=>_attachContext(proxy.override(scope), context, subProxy, descriptorDefaults)\n    };\n    return new Proxy(cache, {\n        /**\n     * A trap for the delete operator.\n     */ deleteProperty (target, prop) {\n            delete target[prop]; // remove from cache\n            delete proxy[prop]; // remove from proxy\n            return true;\n        },\n        /**\n     * A trap for getting property values.\n     */ get (target, prop, receiver) {\n            return _cached(target, prop, ()=>_resolveWithContext(target, prop, receiver));\n        },\n        /**\n     * A trap for Object.getOwnPropertyDescriptor.\n     * Also used by Object.hasOwnProperty.\n     */ getOwnPropertyDescriptor (target, prop) {\n            return target._descriptors.allKeys ? Reflect.has(proxy, prop) ? {\n                enumerable: true,\n                configurable: true\n            } : undefined : Reflect.getOwnPropertyDescriptor(proxy, prop);\n        },\n        /**\n     * A trap for Object.getPrototypeOf.\n     */ getPrototypeOf () {\n            return Reflect.getPrototypeOf(proxy);\n        },\n        /**\n     * A trap for the in operator.\n     */ has (target, prop) {\n            return Reflect.has(proxy, prop);\n        },\n        /**\n     * A trap for Object.getOwnPropertyNames and Object.getOwnPropertySymbols.\n     */ ownKeys () {\n            return Reflect.ownKeys(proxy);\n        },\n        /**\n     * A trap for setting property values.\n     */ set (target, prop, value) {\n            proxy[prop] = value; // set to proxy\n            delete target[prop]; // remove from cache\n            return true;\n        }\n    });\n}\n/**\n * @private\n */ function _descriptors(proxy, defaults = {\n    scriptable: true,\n    indexable: true\n}) {\n    const { _scriptable =defaults.scriptable , _indexable =defaults.indexable , _allKeys =defaults.allKeys  } = proxy;\n    return {\n        allKeys: _allKeys,\n        scriptable: _scriptable,\n        indexable: _indexable,\n        isScriptable: isFunction(_scriptable) ? _scriptable : ()=>_scriptable,\n        isIndexable: isFunction(_indexable) ? _indexable : ()=>_indexable\n    };\n}\nconst readKey = (prefix, name)=>prefix ? prefix + _capitalize(name) : name;\nconst needsSubResolver = (prop, value)=>isObject(value) && prop !== 'adapters' && (Object.getPrototypeOf(value) === null || value.constructor === Object);\nfunction _cached(target, prop, resolve) {\n    if (Object.prototype.hasOwnProperty.call(target, prop) || prop === 'constructor') {\n        return target[prop];\n    }\n    const value = resolve();\n    // cache the resolved value\n    target[prop] = value;\n    return value;\n}\nfunction _resolveWithContext(target, prop, receiver) {\n    const { _proxy , _context , _subProxy , _descriptors: descriptors  } = target;\n    let value = _proxy[prop]; // resolve from proxy\n    // resolve with context\n    if (isFunction(value) && descriptors.isScriptable(prop)) {\n        value = _resolveScriptable(prop, value, target, receiver);\n    }\n    if (isArray(value) && value.length) {\n        value = _resolveArray(prop, value, target, descriptors.isIndexable);\n    }\n    if (needsSubResolver(prop, value)) {\n        // if the resolved value is an object, create a sub resolver for it\n        value = _attachContext(value, _context, _subProxy && _subProxy[prop], descriptors);\n    }\n    return value;\n}\nfunction _resolveScriptable(prop, getValue, target, receiver) {\n    const { _proxy , _context , _subProxy , _stack  } = target;\n    if (_stack.has(prop)) {\n        throw new Error('Recursion detected: ' + Array.from(_stack).join('->') + '->' + prop);\n    }\n    _stack.add(prop);\n    let value = getValue(_context, _subProxy || receiver);\n    _stack.delete(prop);\n    if (needsSubResolver(prop, value)) {\n        // When scriptable option returns an object, create a resolver on that.\n        value = createSubResolver(_proxy._scopes, _proxy, prop, value);\n    }\n    return value;\n}\nfunction _resolveArray(prop, value, target, isIndexable) {\n    const { _proxy , _context , _subProxy , _descriptors: descriptors  } = target;\n    if (typeof _context.index !== 'undefined' && isIndexable(prop)) {\n        return value[_context.index % value.length];\n    } else if (isObject(value[0])) {\n        // Array of objects, return array or resolvers\n        const arr = value;\n        const scopes = _proxy._scopes.filter((s)=>s !== arr);\n        value = [];\n        for (const item of arr){\n            const resolver = createSubResolver(scopes, _proxy, prop, item);\n            value.push(_attachContext(resolver, _context, _subProxy && _subProxy[prop], descriptors));\n        }\n    }\n    return value;\n}\nfunction resolveFallback(fallback, prop, value) {\n    return isFunction(fallback) ? fallback(prop, value) : fallback;\n}\nconst getScope = (key, parent)=>key === true ? parent : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined;\nfunction addScopes(set, parentScopes, key, parentFallback, value) {\n    for (const parent of parentScopes){\n        const scope = getScope(key, parent);\n        if (scope) {\n            set.add(scope);\n            const fallback = resolveFallback(scope._fallback, key, value);\n            if (typeof fallback !== 'undefined' && fallback !== key && fallback !== parentFallback) {\n                // When we reach the descriptor that defines a new _fallback, return that.\n                // The fallback will resume to that new scope.\n                return fallback;\n            }\n        } else if (scope === false && typeof parentFallback !== 'undefined' && key !== parentFallback) {\n            // Fallback to `false` results to `false`, when falling back to different key.\n            // For example `interaction` from `hover` or `plugins.tooltip` and `animation` from `animations`\n            return null;\n        }\n    }\n    return false;\n}\nfunction createSubResolver(parentScopes, resolver, prop, value) {\n    const rootScopes = resolver._rootScopes;\n    const fallback = resolveFallback(resolver._fallback, prop, value);\n    const allScopes = [\n        ...parentScopes,\n        ...rootScopes\n    ];\n    const set = new Set();\n    set.add(value);\n    let key = addScopesFromKey(set, allScopes, prop, fallback || prop, value);\n    if (key === null) {\n        return false;\n    }\n    if (typeof fallback !== 'undefined' && fallback !== prop) {\n        key = addScopesFromKey(set, allScopes, fallback, key, value);\n        if (key === null) {\n            return false;\n        }\n    }\n    return _createResolver(Array.from(set), [\n        ''\n    ], rootScopes, fallback, ()=>subGetTarget(resolver, prop, value));\n}\nfunction addScopesFromKey(set, allScopes, key, fallback, item) {\n    while(key){\n        key = addScopes(set, allScopes, key, fallback, item);\n    }\n    return key;\n}\nfunction subGetTarget(resolver, prop, value) {\n    const parent = resolver._getTarget();\n    if (!(prop in parent)) {\n        parent[prop] = {};\n    }\n    const target = parent[prop];\n    if (isArray(target) && isObject(value)) {\n        // For array of objects, the object is used to store updated values\n        return value;\n    }\n    return target || {};\n}\nfunction _resolveWithPrefixes(prop, prefixes, scopes, proxy) {\n    let value;\n    for (const prefix of prefixes){\n        value = _resolve(readKey(prefix, prop), scopes);\n        if (typeof value !== 'undefined') {\n            return needsSubResolver(prop, value) ? createSubResolver(scopes, proxy, prop, value) : value;\n        }\n    }\n}\nfunction _resolve(key, scopes) {\n    for (const scope of scopes){\n        if (!scope) {\n            continue;\n        }\n        const value = scope[key];\n        if (typeof value !== 'undefined') {\n            return value;\n        }\n    }\n}\nfunction getKeysFromAllScopes(target) {\n    let keys = target._keys;\n    if (!keys) {\n        keys = target._keys = resolveKeysFromAllScopes(target._scopes);\n    }\n    return keys;\n}\nfunction resolveKeysFromAllScopes(scopes) {\n    const set = new Set();\n    for (const scope of scopes){\n        for (const key of Object.keys(scope).filter((k)=>!k.startsWith('_'))){\n            set.add(key);\n        }\n    }\n    return Array.from(set);\n}\nfunction _parseObjectDataRadialScale(meta, data, start, count) {\n    const { iScale  } = meta;\n    const { key ='r'  } = this._parsing;\n    const parsed = new Array(count);\n    let i, ilen, index, item;\n    for(i = 0, ilen = count; i < ilen; ++i){\n        index = i + start;\n        item = data[index];\n        parsed[i] = {\n            r: iScale.parse(resolveObjectKey(item, key), index)\n        };\n    }\n    return parsed;\n}\n\nconst EPSILON = Number.EPSILON || 1e-14;\nconst getPoint = (points, i)=>i < points.length && !points[i].skip && points[i];\nconst getValueAxis = (indexAxis)=>indexAxis === 'x' ? 'y' : 'x';\nfunction splineCurve(firstPoint, middlePoint, afterPoint, t) {\n    // Props to Rob Spencer at scaled innovation for his post on splining between points\n    // http://scaledinnovation.com/analytics/splines/aboutSplines.html\n    // This function must also respect \"skipped\" points\n    const previous = firstPoint.skip ? middlePoint : firstPoint;\n    const current = middlePoint;\n    const next = afterPoint.skip ? middlePoint : afterPoint;\n    const d01 = distanceBetweenPoints(current, previous);\n    const d12 = distanceBetweenPoints(next, current);\n    let s01 = d01 / (d01 + d12);\n    let s12 = d12 / (d01 + d12);\n    // If all points are the same, s01 & s02 will be inf\n    s01 = isNaN(s01) ? 0 : s01;\n    s12 = isNaN(s12) ? 0 : s12;\n    const fa = t * s01; // scaling factor for triangle Ta\n    const fb = t * s12;\n    return {\n        previous: {\n            x: current.x - fa * (next.x - previous.x),\n            y: current.y - fa * (next.y - previous.y)\n        },\n        next: {\n            x: current.x + fb * (next.x - previous.x),\n            y: current.y + fb * (next.y - previous.y)\n        }\n    };\n}\n/**\n * Adjust tangents to ensure monotonic properties\n */ function monotoneAdjust(points, deltaK, mK) {\n    const pointsLen = points.length;\n    let alphaK, betaK, tauK, squaredMagnitude, pointCurrent;\n    let pointAfter = getPoint(points, 0);\n    for(let i = 0; i < pointsLen - 1; ++i){\n        pointCurrent = pointAfter;\n        pointAfter = getPoint(points, i + 1);\n        if (!pointCurrent || !pointAfter) {\n            continue;\n        }\n        if (almostEquals(deltaK[i], 0, EPSILON)) {\n            mK[i] = mK[i + 1] = 0;\n            continue;\n        }\n        alphaK = mK[i] / deltaK[i];\n        betaK = mK[i + 1] / deltaK[i];\n        squaredMagnitude = Math.pow(alphaK, 2) + Math.pow(betaK, 2);\n        if (squaredMagnitude <= 9) {\n            continue;\n        }\n        tauK = 3 / Math.sqrt(squaredMagnitude);\n        mK[i] = alphaK * tauK * deltaK[i];\n        mK[i + 1] = betaK * tauK * deltaK[i];\n    }\n}\nfunction monotoneCompute(points, mK, indexAxis = 'x') {\n    const valueAxis = getValueAxis(indexAxis);\n    const pointsLen = points.length;\n    let delta, pointBefore, pointCurrent;\n    let pointAfter = getPoint(points, 0);\n    for(let i = 0; i < pointsLen; ++i){\n        pointBefore = pointCurrent;\n        pointCurrent = pointAfter;\n        pointAfter = getPoint(points, i + 1);\n        if (!pointCurrent) {\n            continue;\n        }\n        const iPixel = pointCurrent[indexAxis];\n        const vPixel = pointCurrent[valueAxis];\n        if (pointBefore) {\n            delta = (iPixel - pointBefore[indexAxis]) / 3;\n            pointCurrent[`cp1${indexAxis}`] = iPixel - delta;\n            pointCurrent[`cp1${valueAxis}`] = vPixel - delta * mK[i];\n        }\n        if (pointAfter) {\n            delta = (pointAfter[indexAxis] - iPixel) / 3;\n            pointCurrent[`cp2${indexAxis}`] = iPixel + delta;\n            pointCurrent[`cp2${valueAxis}`] = vPixel + delta * mK[i];\n        }\n    }\n}\n/**\n * This function calculates Bézier control points in a similar way than |splineCurve|,\n * but preserves monotonicity of the provided data and ensures no local extremums are added\n * between the dataset discrete points due to the interpolation.\n * See : https://en.wikipedia.org/wiki/Monotone_cubic_interpolation\n */ function splineCurveMonotone(points, indexAxis = 'x') {\n    const valueAxis = getValueAxis(indexAxis);\n    const pointsLen = points.length;\n    const deltaK = Array(pointsLen).fill(0);\n    const mK = Array(pointsLen);\n    // Calculate slopes (deltaK) and initialize tangents (mK)\n    let i, pointBefore, pointCurrent;\n    let pointAfter = getPoint(points, 0);\n    for(i = 0; i < pointsLen; ++i){\n        pointBefore = pointCurrent;\n        pointCurrent = pointAfter;\n        pointAfter = getPoint(points, i + 1);\n        if (!pointCurrent) {\n            continue;\n        }\n        if (pointAfter) {\n            const slopeDelta = pointAfter[indexAxis] - pointCurrent[indexAxis];\n            // In the case of two points that appear at the same x pixel, slopeDeltaX is 0\n            deltaK[i] = slopeDelta !== 0 ? (pointAfter[valueAxis] - pointCurrent[valueAxis]) / slopeDelta : 0;\n        }\n        mK[i] = !pointBefore ? deltaK[i] : !pointAfter ? deltaK[i - 1] : sign(deltaK[i - 1]) !== sign(deltaK[i]) ? 0 : (deltaK[i - 1] + deltaK[i]) / 2;\n    }\n    monotoneAdjust(points, deltaK, mK);\n    monotoneCompute(points, mK, indexAxis);\n}\nfunction capControlPoint(pt, min, max) {\n    return Math.max(Math.min(pt, max), min);\n}\nfunction capBezierPoints(points, area) {\n    let i, ilen, point, inArea, inAreaPrev;\n    let inAreaNext = _isPointInArea(points[0], area);\n    for(i = 0, ilen = points.length; i < ilen; ++i){\n        inAreaPrev = inArea;\n        inArea = inAreaNext;\n        inAreaNext = i < ilen - 1 && _isPointInArea(points[i + 1], area);\n        if (!inArea) {\n            continue;\n        }\n        point = points[i];\n        if (inAreaPrev) {\n            point.cp1x = capControlPoint(point.cp1x, area.left, area.right);\n            point.cp1y = capControlPoint(point.cp1y, area.top, area.bottom);\n        }\n        if (inAreaNext) {\n            point.cp2x = capControlPoint(point.cp2x, area.left, area.right);\n            point.cp2y = capControlPoint(point.cp2y, area.top, area.bottom);\n        }\n    }\n}\n/**\n * @private\n */ function _updateBezierControlPoints(points, options, area, loop, indexAxis) {\n    let i, ilen, point, controlPoints;\n    // Only consider points that are drawn in case the spanGaps option is used\n    if (options.spanGaps) {\n        points = points.filter((pt)=>!pt.skip);\n    }\n    if (options.cubicInterpolationMode === 'monotone') {\n        splineCurveMonotone(points, indexAxis);\n    } else {\n        let prev = loop ? points[points.length - 1] : points[0];\n        for(i = 0, ilen = points.length; i < ilen; ++i){\n            point = points[i];\n            controlPoints = splineCurve(prev, point, points[Math.min(i + 1, ilen - (loop ? 0 : 1)) % ilen], options.tension);\n            point.cp1x = controlPoints.previous.x;\n            point.cp1y = controlPoints.previous.y;\n            point.cp2x = controlPoints.next.x;\n            point.cp2y = controlPoints.next.y;\n            prev = point;\n        }\n    }\n    if (options.capBezierPoints) {\n        capBezierPoints(points, area);\n    }\n}\n\n/**\n * @private\n */ function _isDomSupported() {\n    return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n/**\n * @private\n */ function _getParentNode(domNode) {\n    let parent = domNode.parentNode;\n    if (parent && parent.toString() === '[object ShadowRoot]') {\n        parent = parent.host;\n    }\n    return parent;\n}\n/**\n * convert max-width/max-height values that may be percentages into a number\n * @private\n */ function parseMaxStyle(styleValue, node, parentProperty) {\n    let valueInPixels;\n    if (typeof styleValue === 'string') {\n        valueInPixels = parseInt(styleValue, 10);\n        if (styleValue.indexOf('%') !== -1) {\n            // percentage * size in dimension\n            valueInPixels = valueInPixels / 100 * node.parentNode[parentProperty];\n        }\n    } else {\n        valueInPixels = styleValue;\n    }\n    return valueInPixels;\n}\nconst getComputedStyle = (element)=>element.ownerDocument.defaultView.getComputedStyle(element, null);\nfunction getStyle(el, property) {\n    return getComputedStyle(el).getPropertyValue(property);\n}\nconst positions = [\n    'top',\n    'right',\n    'bottom',\n    'left'\n];\nfunction getPositionedStyle(styles, style, suffix) {\n    const result = {};\n    suffix = suffix ? '-' + suffix : '';\n    for(let i = 0; i < 4; i++){\n        const pos = positions[i];\n        result[pos] = parseFloat(styles[style + '-' + pos + suffix]) || 0;\n    }\n    result.width = result.left + result.right;\n    result.height = result.top + result.bottom;\n    return result;\n}\nconst useOffsetPos = (x, y, target)=>(x > 0 || y > 0) && (!target || !target.shadowRoot);\n/**\n * @param e\n * @param canvas\n * @returns Canvas position\n */ function getCanvasPosition(e, canvas) {\n    const touches = e.touches;\n    const source = touches && touches.length ? touches[0] : e;\n    const { offsetX , offsetY  } = source;\n    let box = false;\n    let x, y;\n    if (useOffsetPos(offsetX, offsetY, e.target)) {\n        x = offsetX;\n        y = offsetY;\n    } else {\n        const rect = canvas.getBoundingClientRect();\n        x = source.clientX - rect.left;\n        y = source.clientY - rect.top;\n        box = true;\n    }\n    return {\n        x,\n        y,\n        box\n    };\n}\n/**\n * Gets an event's x, y coordinates, relative to the chart area\n * @param event\n * @param chart\n * @returns x and y coordinates of the event\n */ function getRelativePosition(event, chart) {\n    if ('native' in event) {\n        return event;\n    }\n    const { canvas , currentDevicePixelRatio  } = chart;\n    const style = getComputedStyle(canvas);\n    const borderBox = style.boxSizing === 'border-box';\n    const paddings = getPositionedStyle(style, 'padding');\n    const borders = getPositionedStyle(style, 'border', 'width');\n    const { x , y , box  } = getCanvasPosition(event, canvas);\n    const xOffset = paddings.left + (box && borders.left);\n    const yOffset = paddings.top + (box && borders.top);\n    let { width , height  } = chart;\n    if (borderBox) {\n        width -= paddings.width + borders.width;\n        height -= paddings.height + borders.height;\n    }\n    return {\n        x: Math.round((x - xOffset) / width * canvas.width / currentDevicePixelRatio),\n        y: Math.round((y - yOffset) / height * canvas.height / currentDevicePixelRatio)\n    };\n}\nfunction getContainerSize(canvas, width, height) {\n    let maxWidth, maxHeight;\n    if (width === undefined || height === undefined) {\n        const container = canvas && _getParentNode(canvas);\n        if (!container) {\n            width = canvas.clientWidth;\n            height = canvas.clientHeight;\n        } else {\n            const rect = container.getBoundingClientRect(); // this is the border box of the container\n            const containerStyle = getComputedStyle(container);\n            const containerBorder = getPositionedStyle(containerStyle, 'border', 'width');\n            const containerPadding = getPositionedStyle(containerStyle, 'padding');\n            width = rect.width - containerPadding.width - containerBorder.width;\n            height = rect.height - containerPadding.height - containerBorder.height;\n            maxWidth = parseMaxStyle(containerStyle.maxWidth, container, 'clientWidth');\n            maxHeight = parseMaxStyle(containerStyle.maxHeight, container, 'clientHeight');\n        }\n    }\n    return {\n        width,\n        height,\n        maxWidth: maxWidth || INFINITY,\n        maxHeight: maxHeight || INFINITY\n    };\n}\nconst round1 = (v)=>Math.round(v * 10) / 10;\n// eslint-disable-next-line complexity\nfunction getMaximumSize(canvas, bbWidth, bbHeight, aspectRatio) {\n    const style = getComputedStyle(canvas);\n    const margins = getPositionedStyle(style, 'margin');\n    const maxWidth = parseMaxStyle(style.maxWidth, canvas, 'clientWidth') || INFINITY;\n    const maxHeight = parseMaxStyle(style.maxHeight, canvas, 'clientHeight') || INFINITY;\n    const containerSize = getContainerSize(canvas, bbWidth, bbHeight);\n    let { width , height  } = containerSize;\n    if (style.boxSizing === 'content-box') {\n        const borders = getPositionedStyle(style, 'border', 'width');\n        const paddings = getPositionedStyle(style, 'padding');\n        width -= paddings.width + borders.width;\n        height -= paddings.height + borders.height;\n    }\n    width = Math.max(0, width - margins.width);\n    height = Math.max(0, aspectRatio ? width / aspectRatio : height - margins.height);\n    width = round1(Math.min(width, maxWidth, containerSize.maxWidth));\n    height = round1(Math.min(height, maxHeight, containerSize.maxHeight));\n    if (width && !height) {\n        // https://github.com/chartjs/Chart.js/issues/4659\n        // If the canvas has width, but no height, default to aspectRatio of 2 (canvas default)\n        height = round1(width / 2);\n    }\n    const maintainHeight = bbWidth !== undefined || bbHeight !== undefined;\n    if (maintainHeight && aspectRatio && containerSize.height && height > containerSize.height) {\n        height = containerSize.height;\n        width = round1(Math.floor(height * aspectRatio));\n    }\n    return {\n        width,\n        height\n    };\n}\n/**\n * @param chart\n * @param forceRatio\n * @param forceStyle\n * @returns True if the canvas context size or transformation has changed.\n */ function retinaScale(chart, forceRatio, forceStyle) {\n    const pixelRatio = forceRatio || 1;\n    const deviceHeight = Math.floor(chart.height * pixelRatio);\n    const deviceWidth = Math.floor(chart.width * pixelRatio);\n    chart.height = Math.floor(chart.height);\n    chart.width = Math.floor(chart.width);\n    const canvas = chart.canvas;\n    // If no style has been set on the canvas, the render size is used as display size,\n    // making the chart visually bigger, so let's enforce it to the \"correct\" values.\n    // See https://github.com/chartjs/Chart.js/issues/3575\n    if (canvas.style && (forceStyle || !canvas.style.height && !canvas.style.width)) {\n        canvas.style.height = `${chart.height}px`;\n        canvas.style.width = `${chart.width}px`;\n    }\n    if (chart.currentDevicePixelRatio !== pixelRatio || canvas.height !== deviceHeight || canvas.width !== deviceWidth) {\n        chart.currentDevicePixelRatio = pixelRatio;\n        canvas.height = deviceHeight;\n        canvas.width = deviceWidth;\n        chart.ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);\n        return true;\n    }\n    return false;\n}\n/**\n * Detects support for options object argument in addEventListener.\n * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support\n * @private\n */ const supportsEventListenerOptions = function() {\n    let passiveSupported = false;\n    try {\n        const options = {\n            get passive () {\n                passiveSupported = true;\n                return false;\n            }\n        };\n        if (_isDomSupported()) {\n            window.addEventListener('test', null, options);\n            window.removeEventListener('test', null, options);\n        }\n    } catch (e) {\n    // continue regardless of error\n    }\n    return passiveSupported;\n}();\n/**\n * The \"used\" size is the final value of a dimension property after all calculations have\n * been performed. This method uses the computed style of `element` but returns undefined\n * if the computed style is not expressed in pixels. That can happen in some cases where\n * `element` has a size relative to its parent and this last one is not yet displayed,\n * for example because of `display: none` on a parent node.\n * @see https://developer.mozilla.org/en-US/docs/Web/CSS/used_value\n * @returns Size in pixels or undefined if unknown.\n */ function readUsedSize(element, property) {\n    const value = getStyle(element, property);\n    const matches = value && value.match(/^(\\d+)(\\.\\d+)?px$/);\n    return matches ? +matches[1] : undefined;\n}\n\n/**\n * @private\n */ function _pointInLine(p1, p2, t, mode) {\n    return {\n        x: p1.x + t * (p2.x - p1.x),\n        y: p1.y + t * (p2.y - p1.y)\n    };\n}\n/**\n * @private\n */ function _steppedInterpolation(p1, p2, t, mode) {\n    return {\n        x: p1.x + t * (p2.x - p1.x),\n        y: mode === 'middle' ? t < 0.5 ? p1.y : p2.y : mode === 'after' ? t < 1 ? p1.y : p2.y : t > 0 ? p2.y : p1.y\n    };\n}\n/**\n * @private\n */ function _bezierInterpolation(p1, p2, t, mode) {\n    const cp1 = {\n        x: p1.cp2x,\n        y: p1.cp2y\n    };\n    const cp2 = {\n        x: p2.cp1x,\n        y: p2.cp1y\n    };\n    const a = _pointInLine(p1, cp1, t);\n    const b = _pointInLine(cp1, cp2, t);\n    const c = _pointInLine(cp2, p2, t);\n    const d = _pointInLine(a, b, t);\n    const e = _pointInLine(b, c, t);\n    return _pointInLine(d, e, t);\n}\n\nconst getRightToLeftAdapter = function(rectX, width) {\n    return {\n        x (x) {\n            return rectX + rectX + width - x;\n        },\n        setWidth (w) {\n            width = w;\n        },\n        textAlign (align) {\n            if (align === 'center') {\n                return align;\n            }\n            return align === 'right' ? 'left' : 'right';\n        },\n        xPlus (x, value) {\n            return x - value;\n        },\n        leftForLtr (x, itemWidth) {\n            return x - itemWidth;\n        }\n    };\n};\nconst getLeftToRightAdapter = function() {\n    return {\n        x (x) {\n            return x;\n        },\n        setWidth (w) {},\n        textAlign (align) {\n            return align;\n        },\n        xPlus (x, value) {\n            return x + value;\n        },\n        leftForLtr (x, _itemWidth) {\n            return x;\n        }\n    };\n};\nfunction getRtlAdapter(rtl, rectX, width) {\n    return rtl ? getRightToLeftAdapter(rectX, width) : getLeftToRightAdapter();\n}\nfunction overrideTextDirection(ctx, direction) {\n    let style, original;\n    if (direction === 'ltr' || direction === 'rtl') {\n        style = ctx.canvas.style;\n        original = [\n            style.getPropertyValue('direction'),\n            style.getPropertyPriority('direction')\n        ];\n        style.setProperty('direction', direction, 'important');\n        ctx.prevTextDirection = original;\n    }\n}\nfunction restoreTextDirection(ctx, original) {\n    if (original !== undefined) {\n        delete ctx.prevTextDirection;\n        ctx.canvas.style.setProperty('direction', original[0], original[1]);\n    }\n}\n\nfunction propertyFn(property) {\n    if (property === 'angle') {\n        return {\n            between: _angleBetween,\n            compare: _angleDiff,\n            normalize: _normalizeAngle\n        };\n    }\n    return {\n        between: _isBetween,\n        compare: (a, b)=>a - b,\n        normalize: (x)=>x\n    };\n}\nfunction normalizeSegment({ start , end , count , loop , style  }) {\n    return {\n        start: start % count,\n        end: end % count,\n        loop: loop && (end - start + 1) % count === 0,\n        style\n    };\n}\nfunction getSegment(segment, points, bounds) {\n    const { property , start: startBound , end: endBound  } = bounds;\n    const { between , normalize  } = propertyFn(property);\n    const count = points.length;\n    let { start , end , loop  } = segment;\n    let i, ilen;\n    if (loop) {\n        start += count;\n        end += count;\n        for(i = 0, ilen = count; i < ilen; ++i){\n            if (!between(normalize(points[start % count][property]), startBound, endBound)) {\n                break;\n            }\n            start--;\n            end--;\n        }\n        start %= count;\n        end %= count;\n    }\n    if (end < start) {\n        end += count;\n    }\n    return {\n        start,\n        end,\n        loop,\n        style: segment.style\n    };\n}\n function _boundSegment(segment, points, bounds) {\n    if (!bounds) {\n        return [\n            segment\n        ];\n    }\n    const { property , start: startBound , end: endBound  } = bounds;\n    const count = points.length;\n    const { compare , between , normalize  } = propertyFn(property);\n    const { start , end , loop , style  } = getSegment(segment, points, bounds);\n    const result = [];\n    let inside = false;\n    let subStart = null;\n    let value, point, prevValue;\n    const startIsBefore = ()=>between(startBound, prevValue, value) && compare(startBound, prevValue) !== 0;\n    const endIsBefore = ()=>compare(endBound, value) === 0 || between(endBound, prevValue, value);\n    const shouldStart = ()=>inside || startIsBefore();\n    const shouldStop = ()=>!inside || endIsBefore();\n    for(let i = start, prev = start; i <= end; ++i){\n        point = points[i % count];\n        if (point.skip) {\n            continue;\n        }\n        value = normalize(point[property]);\n        if (value === prevValue) {\n            continue;\n        }\n        inside = between(value, startBound, endBound);\n        if (subStart === null && shouldStart()) {\n            subStart = compare(value, startBound) === 0 ? i : prev;\n        }\n        if (subStart !== null && shouldStop()) {\n            result.push(normalizeSegment({\n                start: subStart,\n                end: i,\n                loop,\n                count,\n                style\n            }));\n            subStart = null;\n        }\n        prev = i;\n        prevValue = value;\n    }\n    if (subStart !== null) {\n        result.push(normalizeSegment({\n            start: subStart,\n            end,\n            loop,\n            count,\n            style\n        }));\n    }\n    return result;\n}\n function _boundSegments(line, bounds) {\n    const result = [];\n    const segments = line.segments;\n    for(let i = 0; i < segments.length; i++){\n        const sub = _boundSegment(segments[i], line.points, bounds);\n        if (sub.length) {\n            result.push(...sub);\n        }\n    }\n    return result;\n}\n function findStartAndEnd(points, count, loop, spanGaps) {\n    let start = 0;\n    let end = count - 1;\n    if (loop && !spanGaps) {\n        while(start < count && !points[start].skip){\n            start++;\n        }\n    }\n    while(start < count && points[start].skip){\n        start++;\n    }\n    start %= count;\n    if (loop) {\n        end += start;\n    }\n    while(end > start && points[end % count].skip){\n        end--;\n    }\n    end %= count;\n    return {\n        start,\n        end\n    };\n}\n function solidSegments(points, start, max, loop) {\n    const count = points.length;\n    const result = [];\n    let last = start;\n    let prev = points[start];\n    let end;\n    for(end = start + 1; end <= max; ++end){\n        const cur = points[end % count];\n        if (cur.skip || cur.stop) {\n            if (!prev.skip) {\n                loop = false;\n                result.push({\n                    start: start % count,\n                    end: (end - 1) % count,\n                    loop\n                });\n                start = last = cur.stop ? end : null;\n            }\n        } else {\n            last = end;\n            if (prev.skip) {\n                start = end;\n            }\n        }\n        prev = cur;\n    }\n    if (last !== null) {\n        result.push({\n            start: start % count,\n            end: last % count,\n            loop\n        });\n    }\n    return result;\n}\n function _computeSegments(line, segmentOptions) {\n    const points = line.points;\n    const spanGaps = line.options.spanGaps;\n    const count = points.length;\n    if (!count) {\n        return [];\n    }\n    const loop = !!line._loop;\n    const { start , end  } = findStartAndEnd(points, count, loop, spanGaps);\n    if (spanGaps === true) {\n        return splitByStyles(line, [\n            {\n                start,\n                end,\n                loop\n            }\n        ], points, segmentOptions);\n    }\n    const max = end < start ? end + count : end;\n    const completeLoop = !!line._fullLoop && start === 0 && end === count - 1;\n    return splitByStyles(line, solidSegments(points, start, max, completeLoop), points, segmentOptions);\n}\n function splitByStyles(line, segments, points, segmentOptions) {\n    if (!segmentOptions || !segmentOptions.setContext || !points) {\n        return segments;\n    }\n    return doSplitByStyles(line, segments, points, segmentOptions);\n}\n function doSplitByStyles(line, segments, points, segmentOptions) {\n    const chartContext = line._chart.getContext();\n    const baseStyle = readStyle(line.options);\n    const { _datasetIndex: datasetIndex , options: { spanGaps  }  } = line;\n    const count = points.length;\n    const result = [];\n    let prevStyle = baseStyle;\n    let start = segments[0].start;\n    let i = start;\n    function addStyle(s, e, l, st) {\n        const dir = spanGaps ? -1 : 1;\n        if (s === e) {\n            return;\n        }\n        s += count;\n        while(points[s % count].skip){\n            s -= dir;\n        }\n        while(points[e % count].skip){\n            e += dir;\n        }\n        if (s % count !== e % count) {\n            result.push({\n                start: s % count,\n                end: e % count,\n                loop: l,\n                style: st\n            });\n            prevStyle = st;\n            start = e % count;\n        }\n    }\n    for (const segment of segments){\n        start = spanGaps ? start : segment.start;\n        let prev = points[start % count];\n        let style;\n        for(i = start + 1; i <= segment.end; i++){\n            const pt = points[i % count];\n            style = readStyle(segmentOptions.setContext(createContext(chartContext, {\n                type: 'segment',\n                p0: prev,\n                p1: pt,\n                p0DataIndex: (i - 1) % count,\n                p1DataIndex: i % count,\n                datasetIndex\n            })));\n            if (styleChanged(style, prevStyle)) {\n                addStyle(start, i - 1, segment.loop, prevStyle);\n            }\n            prev = pt;\n            prevStyle = style;\n        }\n        if (start < i - 1) {\n            addStyle(start, i - 1, segment.loop, prevStyle);\n        }\n    }\n    return result;\n}\nfunction readStyle(options) {\n    return {\n        backgroundColor: options.backgroundColor,\n        borderCapStyle: options.borderCapStyle,\n        borderDash: options.borderDash,\n        borderDashOffset: options.borderDashOffset,\n        borderJoinStyle: options.borderJoinStyle,\n        borderWidth: options.borderWidth,\n        borderColor: options.borderColor\n    };\n}\nfunction styleChanged(style, prevStyle) {\n    if (!prevStyle) {\n        return false;\n    }\n    const cache = [];\n    const replacer = function(key, value) {\n        if (!isPatternOrGradient(value)) {\n            return value;\n        }\n        if (!cache.includes(value)) {\n            cache.push(value);\n        }\n        return cache.indexOf(value);\n    };\n    return JSON.stringify(style, replacer) !== JSON.stringify(prevStyle, replacer);\n}\n\nexports.HALF_PI = HALF_PI;\nexports.INFINITY = INFINITY;\nexports.PI = PI;\nexports.PITAU = PITAU;\nexports.QUARTER_PI = QUARTER_PI;\nexports.RAD_PER_DEG = RAD_PER_DEG;\nexports.TAU = TAU;\nexports.TWO_THIRDS_PI = TWO_THIRDS_PI;\nexports.Ticks = Ticks;\nexports._addGrace = _addGrace;\nexports._alignPixel = _alignPixel;\nexports._alignStartEnd = _alignStartEnd;\nexports._angleBetween = _angleBetween;\nexports._angleDiff = _angleDiff;\nexports._arrayUnique = _arrayUnique;\nexports._attachContext = _attachContext;\nexports._bezierCurveTo = _bezierCurveTo;\nexports._bezierInterpolation = _bezierInterpolation;\nexports._boundSegment = _boundSegment;\nexports._boundSegments = _boundSegments;\nexports._capitalize = _capitalize;\nexports._computeSegments = _computeSegments;\nexports._createResolver = _createResolver;\nexports._decimalPlaces = _decimalPlaces;\nexports._deprecated = _deprecated;\nexports._descriptors = _descriptors;\nexports._elementsEqual = _elementsEqual;\nexports._factorize = _factorize;\nexports._filterBetween = _filterBetween;\nexports._getParentNode = _getParentNode;\nexports._getStartAndCountOfVisiblePoints = _getStartAndCountOfVisiblePoints;\nexports._int16Range = _int16Range;\nexports._isBetween = _isBetween;\nexports._isClickEvent = _isClickEvent;\nexports._isDomSupported = _isDomSupported;\nexports._isPointInArea = _isPointInArea;\nexports._limitValue = _limitValue;\nexports._longestText = _longestText;\nexports._lookup = _lookup;\nexports._lookupByKey = _lookupByKey;\nexports._measureText = _measureText;\nexports._merger = _merger;\nexports._mergerIf = _mergerIf;\nexports._normalizeAngle = _normalizeAngle;\nexports._parseObjectDataRadialScale = _parseObjectDataRadialScale;\nexports._pointInLine = _pointInLine;\nexports._readValueToProps = _readValueToProps;\nexports._rlookupByKey = _rlookupByKey;\nexports._scaleRangesChanged = _scaleRangesChanged;\nexports._setMinAndMaxByKey = _setMinAndMaxByKey;\nexports._splitKey = _splitKey;\nexports._steppedInterpolation = _steppedInterpolation;\nexports._steppedLineTo = _steppedLineTo;\nexports._textX = _textX;\nexports._toLeftRightCenter = _toLeftRightCenter;\nexports._updateBezierControlPoints = _updateBezierControlPoints;\nexports.addRoundedRectPath = addRoundedRectPath;\nexports.almostEquals = almostEquals;\nexports.almostWhole = almostWhole;\nexports.callback = callback;\nexports.clearCanvas = clearCanvas;\nexports.clipArea = clipArea;\nexports.clone = clone;\nexports.color = color;\nexports.createContext = createContext;\nexports.debounce = debounce;\nexports.defaults = defaults;\nexports.defined = defined;\nexports.descriptors = descriptors;\nexports.distanceBetweenPoints = distanceBetweenPoints;\nexports.drawPoint = drawPoint;\nexports.drawPointLegend = drawPointLegend;\nexports.each = each;\nexports.effects = effects;\nexports.finiteOrDefault = finiteOrDefault;\nexports.fontString = fontString;\nexports.formatNumber = formatNumber;\nexports.getAngleFromPoint = getAngleFromPoint;\nexports.getHoverColor = getHoverColor;\nexports.getMaximumSize = getMaximumSize;\nexports.getRelativePosition = getRelativePosition;\nexports.getRtlAdapter = getRtlAdapter;\nexports.getStyle = getStyle;\nexports.isArray = isArray;\nexports.isFunction = isFunction;\nexports.isNullOrUndef = isNullOrUndef;\nexports.isNumber = isNumber;\nexports.isNumberFinite = isNumberFinite;\nexports.isObject = isObject;\nexports.isPatternOrGradient = isPatternOrGradient;\nexports.listenArrayEvents = listenArrayEvents;\nexports.log10 = log10;\nexports.merge = merge;\nexports.mergeIf = mergeIf;\nexports.niceNum = niceNum;\nexports.noop = noop;\nexports.overrideTextDirection = overrideTextDirection;\nexports.overrides = overrides;\nexports.readUsedSize = readUsedSize;\nexports.renderText = renderText;\nexports.requestAnimFrame = requestAnimFrame;\nexports.resolve = resolve;\nexports.resolveObjectKey = resolveObjectKey;\nexports.restoreTextDirection = restoreTextDirection;\nexports.retinaScale = retinaScale;\nexports.setsEqual = setsEqual;\nexports.sign = sign;\nexports.splineCurve = splineCurve;\nexports.splineCurveMonotone = splineCurveMonotone;\nexports.supportsEventListenerOptions = supportsEventListenerOptions;\nexports.throttled = throttled;\nexports.toDegrees = toDegrees;\nexports.toDimension = toDimension;\nexports.toFont = toFont;\nexports.toFontString = toFontString;\nexports.toLineHeight = toLineHeight;\nexports.toPadding = toPadding;\nexports.toPercentage = toPercentage;\nexports.toRadians = toRadians;\nexports.toTRBL = toTRBL;\nexports.toTRBLCorners = toTRBLCorners;\nexports.uid = uid;\nexports.unclipArea = unclipArea;\nexports.unlistenArrayEvents = unlistenArrayEvents;\nexports.valueOrDefault = valueOrDefault;\n//# sourceMappingURL=helpers.segment.cjs.map\n"],"names":["color$1","uid","id","isNullOrUndef","value","isArray","Array","type","Object","prototype","toString","call","slice","isObject","isNumberFinite","Number","isFinite","valueOrDefault","defaultValue","toDimension","dimension","endsWith","parseFloat","clone","source","map","target","create","keys","klen","length","k","isValidKey","key","indexOf","_merger","options","tval","sval","merge","sources","ilen","merger","current","i","mergeIf","_mergerIf","hasOwnProperty","keyResolvers","v","x","o","y","_splitKey","parts","split","tmp","part","push","resolveObjectKey","obj","resolver","_getKeyResolver","_capitalize","str","charAt","toUpperCase","isFunction","PI","Math","TAU","PITAU","INFINITY","POSITIVE_INFINITY","RAD_PER_DEG","HALF_PI","QUARTER_PI","TWO_THIRDS_PI","log10","sign","almostEquals","epsilon","abs","distanceBetweenPoints","pt1","pt2","sqrt","pow","_angleDiff","a","b","_normalizeAngle","_angleBetween","angle","start","end","sameAngleIsFullCircle","s","e","angleToStart","angleToEnd","startToAngle","endToAngle","_limitValue","min","max","_isBetween","_lookup","table","cmp","index","mid","hi","lo","_lookupByKey","last","ti","arrayEvents","requestAnimFrame","window","callback","requestAnimationFrame","atEdge","t","elasticIn","p","sin","elasticOut","effects","linear","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInSine","cos","easeOutSine","easeInOutSine","easeInExpo","easeOutExpo","easeInOutExpo","easeInCirc","easeOutCirc","easeInOutCirc","easeInElastic","easeOutElastic","easeInOutElastic","easeInBack","easeOutBack","easeInOutBack","easeInBounce","easeOutBounce","m","d","easeInOutBounce","isPatternOrGradient","getHoverColor","Color","saturate","darken","hexString","numbers","colors","intlCache","Map","formatNumber","num","locale","cacheKey","JSON","stringify","formatter","get","Intl","NumberFormat","set","getNumberFormat","format","formatters","values","numeric","tickValue","ticks","this","chart","notation","delta","maxTick","floor","calculateDelta","logDelta","numDecimal","isNaN","minimumFractionDigits","maximumFractionDigits","assign","logarithmic","remain","significand","includes","Ticks","overrides","descriptors","getScope$1","node","n","root","scope","Defaults","constructor","_descriptors","_appliers","animation","undefined","backgroundColor","borderColor","color","datasets","devicePixelRatio","context","platform","getDevicePixelRatio","elements","events","font","family","size","style","lineHeight","weight","hover","hoverBackgroundColor","ctx","hoverBorderColor","hoverColor","indexAxis","interaction","mode","intersect","includeInvisible","maintainAspectRatio","onHover","onClick","parsing","plugins","responsive","scale","scales","showLine","drawActiveElementsOnTop","describe","apply","override","route","name","targetScope","targetName","scopeObject","targetScopeObject","privateName","defineProperties","writable","enumerable","local","appliers","forEach","defaults","_scriptable","startsWith","_indexable","_fallback","delay","duration","easing","fn","from","loop","to","properties","active","resize","show","animations","visible","hide","autoPadding","padding","top","right","bottom","left","display","offset","reverse","beginAtZero","bounds","clip","grace","grid","lineWidth","drawOnChartArea","drawTicks","tickLength","tickWidth","_ctx","tickColor","border","dash","dashOffset","width","title","text","minRotation","maxRotation","mirror","textStrokeWidth","textStrokeColor","autoSkip","autoSkipPadding","labelOffset","minor","major","align","crossAlign","showLabelBackdrop","backdropColor","backdropPadding","toFontString","_measureText","data","gc","longest","string","textWidth","measureText","drawPointLegend","w","xOffset","yOffset","cornerRadius","xOffsetW","yOffsetW","pointStyle","rotation","radius","rad","save","translate","rotate","drawImage","height","restore","beginPath","ellipse","arc","closePath","moveTo","lineTo","SQRT1_2","rect","fill","borderWidth","stroke","_isPointInArea","point","area","margin","decorateText","line","opts","strikethrough","underline","metrics","actualBoundingBoxLeft","actualBoundingBoxRight","actualBoundingBoxAscent","actualBoundingBoxDescent","yDecoration","strokeStyle","fillStyle","decorationWidth","drawBackdrop","oldColor","fillRect","LINE_HEIGHT","FONT_STYLE","toLineHeight","matches","match","_readValueToProps","props","ret","objProps","read","prop","toTRBL","createContext","parentContext","_createResolver","scopes","prefixes","rootScopes","fallback","getTarget","finalRootScopes","_resolve","cache","Symbol","toStringTag","_cacheable","_scopes","_rootScopes","_getTarget","Proxy","deleteProperty","_keys","_cached","proxy","prefix","readKey","needsSubResolver","createSubResolver","_resolveWithPrefixes","getOwnPropertyDescriptor","Reflect","getPrototypeOf","has","getKeysFromAllScopes","ownKeys","storage","_storage","scriptable","indexable","_allKeys","allKeys","isScriptable","isIndexable","resolve","resolveFallback","getScope","parent","addScopes","parentScopes","parentFallback","add","allScopes","Set","addScopesFromKey","subGetTarget","item","filter","resolveKeysFromAllScopes","EPSILON","getPoint","points","skip","getValueAxis","splineCurve","firstPoint","middlePoint","afterPoint","previous","next","d01","d12","s01","s12","fa","fb","splineCurveMonotone","valueAxis","pointsLen","deltaK","mK","pointBefore","pointCurrent","pointAfter","slopeDelta","alphaK","betaK","tauK","squaredMagnitude","monotoneAdjust","iPixel","vPixel","monotoneCompute","capControlPoint","pt","_isDomSupported","document","_getParentNode","domNode","parentNode","host","parseMaxStyle","styleValue","parentProperty","valueInPixels","parseInt","getComputedStyle","element","ownerDocument","defaultView","getStyle","el","property","getPropertyValue","positions","getPositionedStyle","styles","suffix","result","pos","round1","round","supportsEventListenerOptions","passiveSupported","passive","addEventListener","removeEventListener","_pointInLine","p1","p2","propertyFn","between","compare","normalize","normalizeSegment","count","_boundSegment","segment","startBound","endBound","getSegment","prevValue","inside","subStart","prev","readStyle","borderCapStyle","borderDash","borderDashOffset","borderJoinStyle","styleChanged","prevStyle","replacer","exports","_addGrace","minmax","change","keepZero","_alignPixel","pixel","currentDevicePixelRatio","halfWidth","_alignStartEnd","_arrayUnique","items","_attachContext","subProxy","descriptorDefaults","_proxy","_context","_subProxy","_stack","setContext","receiver","getValue","Error","join","delete","_resolveScriptable","arr","_resolveArray","_resolveWithContext","configurable","_bezierCurveTo","flip","bezierCurveTo","cp1x","cp2x","cp1y","cp2y","_bezierInterpolation","cp1","cp2","c","_boundSegments","segments","sub","_computeSegments","segmentOptions","spanGaps","_loop","findStartAndEnd","chartContext","_chart","getContext","baseStyle","_datasetIndex","datasetIndex","addStyle","l","st","dir","p0","p0DataIndex","p1DataIndex","doSplitByStyles","splitByStyles","cur","stop","solidSegments","_fullLoop","_decimalPlaces","_deprecated","console","warn","_elementsEqual","a0","a1","v0","v1","_factorize","sort","pop","_filterBetween","_getStartAndCountOfVisiblePoints","meta","animationsDisabled","pointCount","_sorted","iScale","vScale","_parsed","dataset","axis","minDefined","maxDefined","getUserBounds","getPixelForValue","distanceToDefinedLo","findIndex","distanceToDefinedHi","_int16Range","_isClickEvent","_longestText","arrayOfThings","garbageCollect","j","jlen","thing","nestedThing","gcLen","splice","_parseObjectDataRadialScale","_parsing","parsed","r","parse","_rlookupByKey","_scaleRangesChanged","xScale","yScale","_scaleRanges","newRanges","xmin","xmax","ymin","ymax","changed","_setMinAndMaxByKey","array","_steppedInterpolation","_steppedLineTo","midpoint","_textX","rtl","_toLeftRightCenter","_updateBezierControlPoints","controlPoints","cubicInterpolationMode","tension","capBezierPoints","inArea","inAreaPrev","inAreaNext","addRoundedRectPath","h","topLeft","bottomLeft","bottomRight","topRight","almostWhole","rounded","args","thisArg","clearCanvas","canvas","resetTransform","clearRect","clipArea","debounce","timeout","clearTimeout","setTimeout","defined","drawPoint","each","loopable","len","finiteOrDefault","fontString","pixelSize","fontStyle","fontFamily","getAngleFromPoint","centrePoint","anglePoint","distanceFromXCenter","distanceFromYCenter","radialDistanceFromCenter","atan2","distance","getMaximumSize","bbWidth","bbHeight","aspectRatio","margins","maxWidth","maxHeight","containerSize","container","getBoundingClientRect","containerStyle","containerBorder","containerPadding","clientWidth","clientHeight","getContainerSize","boxSizing","borders","paddings","getRelativePosition","event","borderBox","box","touches","offsetX","offsetY","shadowRoot","useOffsetPos","clientX","clientY","getCanvasPosition","getRtlAdapter","rectX","setWidth","textAlign","xPlus","leftForLtr","itemWidth","getRightToLeftAdapter","_itemWidth","isNumber","toPrimitive","isNonPrimitive","listenArrayEvents","listener","_chartjs","listeners","defineProperty","method","base","res","object","niceNum","range","roundedRange","niceRange","fraction","noop","overrideTextDirection","direction","original","getPropertyPriority","setProperty","prevTextDirection","readUsedSize","renderText","lines","strokeWidth","strokeColor","translation","textBaseline","setRenderOpts","backdrop","strokeText","fillText","inputs","info","cacheable","restoreTextDirection","retinaScale","forceRatio","forceStyle","pixelRatio","deviceHeight","deviceWidth","setTransform","setsEqual","throttled","argsToUse","ticking","toDegrees","radians","toFont","toPadding","toPercentage","toRadians","degrees","toTRBLCorners","unclipArea","unlistenArrayEvents","stub"],"sourceRoot":""}